From: <bi...@us...> - 2007-10-27 00:42:30
|
Revision: 1102 http://oorexx.svn.sourceforge.net/oorexx/?rev=1102&view=rev Author: bigrixx Date: 2007-10-26 17:42:29 -0700 (Fri, 26 Oct 2007) Log Message: ----------- More warning removal work. Modified Paths: -------------- sandbox/rick/warnings2/kernel/classes/ArrayClass.cpp sandbox/rick/warnings2/kernel/classes/IntegerClass.cpp sandbox/rick/warnings2/kernel/classes/IntegerClass.hpp sandbox/rick/warnings2/kernel/classes/NumberStringClass.cpp sandbox/rick/warnings2/kernel/instructions/ParseTrigger.cpp sandbox/rick/warnings2/kernel/platform/unix/ExternalFunctions.cpp sandbox/rick/warnings2/kernel/runtime/GlobalData.cpp sandbox/rick/warnings2/kernel/runtime/Numerics.cpp sandbox/rick/warnings2/kernel/runtime/Numerics.hpp sandbox/rick/warnings2/kernel/runtime/RexxActivation.cpp Modified: sandbox/rick/warnings2/kernel/classes/ArrayClass.cpp =================================================================== --- sandbox/rick/warnings2/kernel/classes/ArrayClass.cpp 2007-10-26 21:42:27 UTC (rev 1101) +++ sandbox/rick/warnings2/kernel/classes/ArrayClass.cpp 2007-10-27 00:42:29 UTC (rev 1102) @@ -76,6 +76,7 @@ #include "ArrayClass.hpp" #include "MutableBufferClass.hpp" + extern ACTIVATION_SETTINGS *current_settings; void RexxArray::init(size_t _size, size_t maxSize) Modified: sandbox/rick/warnings2/kernel/classes/IntegerClass.cpp =================================================================== --- sandbox/rick/warnings2/kernel/classes/IntegerClass.cpp 2007-10-26 21:42:27 UTC (rev 1101) +++ sandbox/rick/warnings2/kernel/classes/IntegerClass.cpp 2007-10-27 00:42:29 UTC (rev 1102) @@ -51,8 +51,9 @@ #include "RexxActivation.hpp" #include "RexxActivity.hpp" #include "RexxBuiltinFunctions.h" +#include "Numerics.hpp" -extern long validMaxWhole[]; + /* current global settings */ extern ACTIVATION_SETTINGS *current_settings; /* define an operator forwarding */ @@ -228,7 +229,7 @@ } /* is the long value expressable as a*/ /* whole number in REXX term. */ - if (digits < 9 && labs((INT)this->value) >= validMaxWhole[digits - 1]) { + if (digits < 9 && labs((INT)this->value) >= Numerics::validMaxWhole[digits - 1]) { return NO_LONG; /* nope, not a valid long. */ } return this->value; /* return the value directly */ Modified: sandbox/rick/warnings2/kernel/classes/IntegerClass.hpp =================================================================== --- sandbox/rick/warnings2/kernel/classes/IntegerClass.hpp 2007-10-26 21:42:27 UTC (rev 1101) +++ sandbox/rick/warnings2/kernel/classes/IntegerClass.hpp 2007-10-27 00:42:29 UTC (rev 1102) @@ -146,6 +146,8 @@ RexxString *stringrep; /* integer string representation */ int value; /* actual integer value */ + + static int validMaxWhole[]; // table of maximum values per digits setting }; class RexxIntegerClass : public RexxClass { Modified: sandbox/rick/warnings2/kernel/classes/NumberStringClass.cpp =================================================================== --- sandbox/rick/warnings2/kernel/classes/NumberStringClass.cpp 2007-10-26 21:42:27 UTC (rev 1101) +++ sandbox/rick/warnings2/kernel/classes/NumberStringClass.cpp 2007-10-27 00:42:29 UTC (rev 1102) @@ -56,7 +56,6 @@ /* current global settings */ extern ACTIVATION_SETTINGS *current_settings; -extern long validMaxWhole[]; /* MHES 20050108 deprecated */ #define string_forwarder(method)\ @@ -618,7 +617,7 @@ } /* is long value expressable as a */ /* whole number in REXX term. */ - if (createdDigits <= 9 && intnum >= validMaxWhole[NumDigits -1]) { + if (createdDigits <= 9 && intnum >= Numerics::validMaxWhole[NumDigits -1]) { return NO_LONG; /* nope, not a valid long. */ } Modified: sandbox/rick/warnings2/kernel/instructions/ParseTrigger.cpp =================================================================== --- sandbox/rick/warnings2/kernel/instructions/ParseTrigger.cpp 2007-10-26 21:42:27 UTC (rev 1101) +++ sandbox/rick/warnings2/kernel/instructions/ParseTrigger.cpp 2007-10-27 00:42:29 UTC (rev 1102) @@ -166,18 +166,18 @@ /* 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 */ + _value = target->remainder(); /* extract the remainder */ else - value = target->getWord(); /* just get the next word */ + _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 */ + 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); + context->traceIntermediate(_value, TRACE_PREFIX_DUMMY); } } else { /* not tracing, can optimize */ @@ -186,11 +186,11 @@ 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 */ + _value = target->remainder(); /* extract the remainder */ else - value = target->getWord(); /* just get the next word */ + _value = target->getWord(); /* just get the next word */ /* set the value */ - variable->assign(context, stack, value); + variable->assign(context, stack, _value); } else { /* dummy variable, just skip it */ if (i + 1 == size) /* last variable? */ Modified: sandbox/rick/warnings2/kernel/platform/unix/ExternalFunctions.cpp =================================================================== --- sandbox/rick/warnings2/kernel/platform/unix/ExternalFunctions.cpp 2007-10-26 21:42:27 UTC (rev 1101) +++ sandbox/rick/warnings2/kernel/platform/unix/ExternalFunctions.cpp 2007-10-27 00:42:29 UTC (rev 1102) @@ -242,7 +242,7 @@ return(0); /* merge the strings */ sprintf(dir_buf, "%s/%s", home_dir, st); - return dir_buf; + return dir_buf; } else { @@ -253,7 +253,7 @@ if (!dir_buf) return(0); sprintf(dir_buf, "%s/", home_dir); - return dir_buf; + return dir_buf; } } else if (*(st) == '~') @@ -288,13 +288,13 @@ /* get space for the buf */ dir_buf = (char *)malloc(strlen(ppwd->pw_dir)+strlen(slash)+2); if (!dir_buf) - return NULL; + return NULL; /* merge the strings */ sprintf(dir_buf, "%s/%s", ppwd->pw_dir, slash); } return dir_buf; /* directory change to */ } - return NULL; + return NULL; } /****************************************************************************/ @@ -839,7 +839,7 @@ } /* Loop through the saved env */ /* entries and restore them */ - for(;(current-begin)<size;current+=(strlen(current)+1)){ + for(;(size_t)(current-begin)<size;current+=(strlen(current)+1)){ Environment = environ; /* get the environment */ del = NULL; np = current; Modified: sandbox/rick/warnings2/kernel/runtime/GlobalData.cpp =================================================================== --- sandbox/rick/warnings2/kernel/runtime/GlobalData.cpp 2007-10-26 21:42:27 UTC (rev 1101) +++ sandbox/rick/warnings2/kernel/runtime/GlobalData.cpp 2007-10-27 00:42:29 UTC (rev 1102) @@ -263,26 +263,9 @@ /* all zeros, which is a non-valid */ /* float number */ double NO_DOUBLE; /* non-exsistent double value */ -/* MHES -int NO_INT = 0x80000000; -long NO_LONG = 0x80000000; -PCHAR NO_CSTRING = NULL; -*/ -/* Array for valid whole number at various digits settings */ -/* for value 1-8. */ -extern long validMaxWhole[] = {10, - 100, - 1000, - 10000, - 100000, - 1000000, - 10000000, - 100000000, - 1000000000}; - MemorySegmentPool *GlobalCurrentPool = NULL; //wge NULL SysSharedSemaphoreDefn /* semaphore definitions */ Modified: sandbox/rick/warnings2/kernel/runtime/Numerics.cpp =================================================================== --- sandbox/rick/warnings2/kernel/runtime/Numerics.cpp 2007-10-26 21:42:27 UTC (rev 1101) +++ sandbox/rick/warnings2/kernel/runtime/Numerics.cpp 2007-10-27 00:42:29 UTC (rev 1102) @@ -73,6 +73,19 @@ /* default numeric form setting */ bool Numerics::DEFAULT_FORM = Numerics::FORM_SCIENTIFIC; + +/* Array for valid whole number at various digits settings */ +/* for value 1-8. */ +int Numerics::validMaxWhole[] = {10, + 100, + 1000, + 10000, + 100000, + 1000000, + 10000000, + 100000000, + 1000000000}; + /** * Convert a signed int64 object into the appropriate Rexx * object type. @@ -167,7 +180,7 @@ temp = (wholenumber_t)nString->longValue(ARGUMENT_DIGITS); // if not a valid whole number, reject this too - if (temp == NO_LONG) + if (temp == (wholenumber_t)NO_LONG) { return false; } Modified: sandbox/rick/warnings2/kernel/runtime/Numerics.hpp =================================================================== --- sandbox/rick/warnings2/kernel/runtime/Numerics.hpp 2007-10-26 21:42:27 UTC (rev 1101) +++ sandbox/rick/warnings2/kernel/runtime/Numerics.hpp 2007-10-27 00:42:29 UTC (rev 1102) @@ -80,6 +80,8 @@ static stringsize_t formatWholeNumber(wholenumber_t integer, stringchar_t *dest); static stringsize_t formatStringSize(stringsize_t integer, stringchar_t *dest); static stringsize_t formatInt64(int64_t integer, stringchar_t *dest); + + static int validMaxWhole[]; // table of maximum values per digits setting }; #endif Modified: sandbox/rick/warnings2/kernel/runtime/RexxActivation.cpp =================================================================== --- sandbox/rick/warnings2/kernel/runtime/RexxActivation.cpp 2007-10-26 21:42:27 UTC (rev 1101) +++ sandbox/rick/warnings2/kernel/runtime/RexxActivation.cpp 2007-10-27 00:42:29 UTC (rev 1102) @@ -114,9 +114,9 @@ } RexxActivation::RexxActivation( - RexxObject * receiver, /* message receiver */ - RexxMethod * method, /* method to run */ - RexxActivity * activity, /* current activity */ + RexxObject * _receiver, /* message receiver */ + RexxMethod * _method, /* method to run */ + RexxActivity * _activity, /* current activity */ RexxString * msgname, /* message name processed */ RexxActivation * activation, /* parent activation */ int context ) /* execution context */ @@ -135,13 +135,13 @@ } this->settings.intermediate_trace = FALSE; this->activation_context = context; /* save the context */ - this->receiver = receiver; /* save the message receiver */ - this->method = method; /* save the method pointer */ - this->code = method->rexxCode; /* get the REXX method object */ + this->receiver = _receiver; /* save the message receiver */ + this->method = _method; /* save the method pointer */ + this->code = _method->rexxCode; /* get the REXX method object */ this->source = this->code->u_source; /* save the source */ - this->activity = activity; /* save the activity pointer */ + this->activity = _activity; /* save the activity pointer */ /* save the sender activation */ - this->sender = activity->currentAct(); + this->sender = _activity->currentAct(); this->execution_state = ACTIVE; /* we are now in active execution */ this->object_scope = SCOPE_RELEASED; /* scope not reserved yet */ /* default to method for now */ @@ -153,7 +153,7 @@ /* a properly set up stack (::live() */ /* is called). Setting the NoRefBit */ /* when creating the stack avoids it.*/ - activity->allocateStackFrame(&this->stack, this->code->maxStack); + _activity->allocateStackFrame(&this->stack, this->code->maxStack); SetObjectHasReferences(this); if (context&INTERNAL_LEVEL_CALL) { /* internal call or interpret? */ /* inherit parents settings */ @@ -202,16 +202,16 @@ /******************************************************************************/ { /* go run this */ - RexxObject * result; - result = this->run(NULL, 0, OREF_NULL); - if (result != OREF_NULL) discard(result); - return result; + RexxObject * resultObj; + resultObj = this->run(NULL, 0, OREF_NULL); + if (resultObj != OREF_NULL) discard(result); + return resultObj; } RexxObject * RexxActivation::run( - RexxObject **arglist, /* argument list to the activity */ - size_t argcount, /* the argument count */ + RexxObject **_arglist, /* argument list to the activity */ + size_t _argcount, /* the argument count */ RexxInstruction * start) /* starting instruction */ /******************************************************************************/ /* Function: Run a REXX method...this is it! This is the heart of the */ @@ -224,10 +224,8 @@ #ifndef FIXEDTIMERS /* currently disabled */ LONG instructionCount; /* instructions without yielding */ #endif - RexxExpressionStack *stack; /* current execution stack */ - RexxInstruction *next; /* next instruction to execute */ - RexxObject *result; /* the return result */ BOOL fDebuggerSet; /* debug exits installed? */ + RexxObject *resultObj = OREF_NULL; /* not a reply restart situation? */ if (this->execution_state != REPLIED) { @@ -238,8 +236,8 @@ /* remember that we have sys exits */ this->settings.flags |= clause_exits; } - this->arglist = arglist; /* set the argument list */ - this->argcount = argcount; + this->arglist = _arglist; /* set the argument list */ + this->argcount = _argcount; /* first entry into here? */ if (this->activation_context&TOP_LEVEL_CALL) { /* save entry argument list for */ @@ -328,18 +326,18 @@ } /* now fall back into processing loop*/ } - stack = &this->stack; /* load up the stack */ + RexxExpressionStack *localStack = &this->stack; /* load up the stack */ #ifndef FIXEDTIMERS /* currently disabled */ instructionCount = 0; /* no instructions yet */ #endif - next = this->next; /* get the next instruction */ + RexxInstruction *nextInst = this->next; /* get the next instruction */ SysClauseBoundary(this); /* take one shot at clause stuff */ /* if no debug exit is set, calls in */ /* the execution loop can be skipped */ fDebuggerSet = this->activity->nestedInfo.exitset; /* loop until we get a terminating */ - while (next != OREF_NULL) { /* condition */ + while (nextInst != OREF_NULL) { /* condition */ #ifdef FIXEDTIMERS /* currently disabled (active on Win)*/ /* has time Slice expired? */ @@ -354,13 +352,13 @@ } #endif - this->current = next; /* set the next instruction */ - this->next = next->nextInstruction;/* prefetch the next clause */ + this->current = nextInst; /* set the next instruction */ + this->next = nextInst->nextInstruction;/* prefetch the next clause */ if (fDebuggerSet && !(this->settings.dbg_flags&dbg_trace)) this->callDbgExit(); - next->execute(this, stack); /* execute the instruction */ - stack->clear(); /* Force the stack clear */ + nextInst->execute(this, localStack); /* execute the instruction */ + localStack->clear(); /* Force the stack clear */ if (fDebuggerSet) this->dbgCheckEndStepOver(); /* clear stepover flag */ @@ -371,7 +369,7 @@ if (this->settings.flags&clause_boundary) this->processClauseBoundary(); /* go do the clause boundary stuff */ - next = this->next; /* get the next instruction */ + nextInst = this->next; /* get the next instruction */ } if (fDebuggerSet) @@ -395,15 +393,15 @@ /* merge any pending conditions */ this->sender->mergeTraps(this->condition_queue, this->handler_queue); } - result = this->result; /* save the result */ - if (result != OREF_NULL) save(result); + resultObj = this->result; /* save the result */ + if (resultObj != OREF_NULL) save(resultObj); this->activity->pop(FALSE); /* now pop the current activity */ /* now go run the uninit stuff */ TheActivityClass->checkUninitQueue(); } else { /* execution_state is REPLIED */ - result = this->result; /* save the result */ - if (result != OREF_NULL) save(result); + resultObj = this->result; /* save the result */ + if (resultObj != OREF_NULL) save(resultObj); /* reset the next instruction */ this->next = this->current->nextInstruction; oldActivity = this->activity; /* save the current activity */ @@ -416,12 +414,12 @@ /* save the pointer to the start of our stack frame. We're */ /* going to need to release this after we migrate everything */ /* over. */ - RexxObject **framePtr = stack->getFrame(); + RexxObject **framePtr = localStack->getFrame(); /* migrate the local variables and the expression stack to the */ /* new activity. NOTE: these must be done in this order to */ /* get them allocated from the new activity in the correct */ /* order. */ - stack->migrate(this->activity); + localStack->migrate(this->activity); settings.local_variables.migrate(this->activity); /* if we have arguments, we need to migrate those also, as they are subject to overwriting once we return to the parent activation. */ if (argcount > 0) { @@ -448,7 +446,7 @@ this->activity->run(); /* continue running the new activity */ oldActivity->yield(OREF_NULL); /* give other activity a chance to go*/ } - return result; /* return the result object */ + return resultObj; /* return the result object */ } void RexxActivation::processTraps() @@ -515,7 +513,7 @@ /* Function: Generate a string form of the current trace setting */ /******************************************************************************/ { - UCHAR setting[3]; /* returned trace setting */ + char setting[3]; /* returned trace setting */ RexxString *result; /* returned result */ setting[0] = '\0'; /* start with a null string */ @@ -525,15 +523,14 @@ /* add current trace option */ setting[1] = this->settings.traceoption; /* create a string form */ - result = new_string((PCHAR)setting, 2); + return new_string(setting, 2); } else { /* no debug prefix */ /* add current trace option */ setting[0] = this->settings.traceoption; /* create a string form */ - result = new_string((PCHAR)setting, 1); + return new_string(setting, 1); } - return result; /* return the setting */ } @@ -778,7 +775,7 @@ } void RexxActivation::reply( - RexxObject * result) /* returned REPLY result */ + RexxObject * resultObj) /* returned REPLY result */ /******************************************************************************/ /* Function: Process a REXX REPLY instruction */ /******************************************************************************/ @@ -791,18 +788,18 @@ /* change execution state to */ this->execution_state = REPLIED; /* terminate the main loop */ this->next = OREF_NULL; /* turn off execution engine */ - this->result = result; /* save the result value */ + this->result = resultObj; /* save the result value */ } void RexxActivation::returnFrom( - RexxObject * result) /* returned RETURN/EXIT result */ + RexxObject * resultObj) /* returned RETURN/EXIT result */ /******************************************************************************/ /* Function: process a REXX RETURN instruction */ /******************************************************************************/ { /* already had a reply issued? */ - if (this->settings.flags&reply_issued && result != OREF_NULL) + if (this->settings.flags&reply_issued && resultObj != OREF_NULL) /* flag this as an error */ report_exception(Error_Execution_reply_return); /* processing an Interpret */ @@ -810,12 +807,12 @@ this->execution_state = RETURNED; /* this is a returned state */ this->next = OREF_NULL; /* turn off execution engine */ /* cause a return in the sender */ - this->sender->returnFrom(result); /* activity */ + this->sender->returnFrom(resultObj); /* activity */ } else { this->execution_state = RETURNED; /* the state is returned */ this->next = OREF_NULL; /* turn off execution engine */ - this->result = result; /* save the return result */ + this->result = resultObj; /* save the return result */ /* real program call? */ if (this->activation_context&PROGRAM_LEVEL_CALL) /* run termination exit */ @@ -979,30 +976,30 @@ RexxObject * target, /* target object */ RexxString * message, /* message to send */ RexxObject * superClass, /* class over ride */ - RexxObject ** arguments, /* message arguments */ - size_t argcount, /* count of message arguments */ + RexxObject ** _arguments, /* message arguments */ + size_t _argcount, /* count of message arguments */ BOOL continuing) /* return/continue flag */ /******************************************************************************/ /* Function: Process a REXX FORWARD instruction */ /******************************************************************************/ { - RexxObject *result; /* message result */ + RexxObject *resultObj; /* message result */ if (target == OREF_NULL) /* no target? */ target = this->receiver; /* use this */ if (message == OREF_NULL) /* no message override? */ message = this->settings.msgname; /* use same message name */ - if (arguments == OREF_NULL) { /* no arguments given? */ - arguments = this->arglist; /* use the same arguments */ - argcount = this->argcount; + if (_arguments == OREF_NULL) { /* no arguments given? */ + _arguments = this->arglist; /* use the same arguments */ + _argcount = this->argcount; } if (continuing) { /* just processing the message? */ if (superClass == OREF_NULL) /* no override? */ /* issue the message and return */ - return target->messageSend(message, argcount, arguments); + return target->messageSend(message, _argcount, _arguments); else /* issue the message with override */ - return target->messageSend(message, argcount, arguments, superClass); + return target->messageSend(message, _argcount, _arguments, superClass); } else { /* got to shut down and issue */ this->settings.flags |= forwarded; /* we are now a phantom activation */ @@ -1020,13 +1017,13 @@ this->settings.flags |= debug_bypass; if (superClass == OREF_NULL) /* no over ride? */ /* issue the simple message */ - result = target->messageSend(message, argcount, arguments); + resultObj = target->messageSend(message, _argcount, _arguments); else /* use the full override */ - result = target->messageSend(message, argcount, arguments, superClass); - this->result = result; /* save the result value */ + result = target->messageSend(message, _argcount, _arguments, superClass); + this->result = resultObj; /* save the result value */ /* already had a reply issued? */ - if (this->settings.flags&reply_issued && result != OREF_NULL) + if (this->settings.flags&reply_issued && resultObj != OREF_NULL) /* flag this as an error */ report_exception(Error_Execution_reply_exit); this->termination(); /* run "program" termination method */ @@ -1036,7 +1033,7 @@ } void RexxActivation::exitFrom( - RexxObject * result) /* EXIT result */ + RexxObject * resultObj) /* EXIT result */ /******************************************************************************/ /* Function: Process a REXX exit instruction */ /******************************************************************************/ @@ -1045,7 +1042,7 @@ this->execution_state = RETURNED; /* this is an EXIT for real */ this->next = OREF_NULL; /* turn off execution engine */ - this->result = result; /* save the result value */ + this->result = resultObj; /* save the result value */ /* switch debug off to avoid debug */ /* pause after exit entered from an */ this->settings.flags &= ~trace_debug;/* interactive debug prompt */ @@ -1071,7 +1068,7 @@ activation = CurrentActivity->currentAct(); } while (!activation->isTopLevel()); - activation->exitFrom(result); /* tell this level to terminate */ + activation->exitFrom(resultObj); /* tell this level to terminate */ /* unwind and process the termination*/ longjmp(activation->conditionjump,1); } @@ -1198,7 +1195,7 @@ RexxObject * rc, /* information assigned to RC */ RexxString * description, /* description of the condition */ RexxObject * additional, /* extra descriptive information */ - RexxObject * result, /* return result */ + RexxObject * resultObj, /* return result */ RexxDirectory * conditionobj ) /* propagated condition object */ /******************************************************************************/ /* Function: Raise a condition using exit semantics for the returned value. */ @@ -1208,13 +1205,13 @@ /* instruction activation? */ if (this->activation_context&TOP_LEVEL_CALL) { /* do the real condition raise */ - this->raise(condition, rc, description, additional, result, conditionobj); + this->raise(condition, rc, description, additional, resultObj, conditionobj); return; /* return if processed */ } /* reached the top level? */ if (this->sender == (RexxActivation *)TheNilObject) { - this->exitFrom(result); /* turn into an exit instruction */ + this->exitFrom(resultObj); /* turn into an exit instruction */ } else { /* real program call? */ @@ -1225,7 +1222,7 @@ this->termination(); /* remove guarded status on object */ this->activity->pop(FALSE); /* pop ourselves off active list */ /* propogate the condition backward */ - this->sender->raiseExit(condition, rc, description, additional, result, conditionobj); + this->sender->raiseExit(condition, rc, description, additional, resultObj, conditionobj); } } @@ -1235,13 +1232,13 @@ RexxObject * rc, /* information assigned to RC */ RexxString * description, /* description of the condition */ RexxObject * additional, /* extra descriptive information */ - RexxObject * result, /* return result */ + RexxObject * resultObj, /* return result */ RexxDirectory * conditionobj ) /* propagated condition object */ /******************************************************************************/ /* Function: Raise a give REXX condition */ /******************************************************************************/ { - RexxActivation *sender; /* "invoker" of current activation */ + RexxActivation *_sender; /* "invoker" of current activation */ BOOL propagated; /* propagated syntax condition */ /* propagating an existing condition?*/ @@ -1251,8 +1248,8 @@ propagated = TRUE; /* this is propagated */ /* fill in the propagation status */ conditionobj->put(TheTrueObject, OREF_PROPAGATED); - if (result == OREF_NULL) /* no result specified? */ - result = conditionobj->at(OREF_RESULT); + if (resultObj == OREF_NULL) /* no result specified? */ + resultObj = conditionobj->at(OREF_RESULT); } else { /* build a condition object */ conditionobj = new_directory(); /* get a new directory */ @@ -1270,8 +1267,8 @@ conditionobj->put(description, OREF_DESCRIPTION); if (additional != OREF_NULL) /* or additional information */ conditionobj->put(additional, OREF_ADDITIONAL); - if (result != OREF_NULL) /* or a result object */ - conditionobj->put(result, OREF_RESULT); + if (resultObj != OREF_NULL) /* or a result object */ + conditionobj->put(resultObj, OREF_RESULT); /* fatal SYNTAX error? */ if (condition->strCompare(CHAR_SYNTAX)) { @@ -1284,18 +1281,18 @@ } else /* go raise the error */ - CurrentActivity->raiseException(((RexxInteger *)rc)->getValue(), NULL, OREF_NULL, description, (RexxArray *)additional, result); + CurrentActivity->raiseException(((RexxInteger *)rc)->getValue(), NULL, OREF_NULL, description, (RexxArray *)additional, resultObj); } else { /* normal condition trapping */ /* get the sender object (if any) */ - sender = this->senderAct(); + _sender = this->senderAct(); /* do we have a sender that is */ /* trapping this condition? */ /* do we have a sender? */ - if (sender != (RexxActivation *)TheNilObject) + if (_sender != (RexxActivation *)TheNilObject) /* "tickle them" with this */ this->sender->trap(condition, conditionobj); - this->returnFrom(result); /* process the return part */ + this->returnFrom(resultObj); /* process the return part */ longjmp(this->conditionjump,1); /* unwind and process the termination*/ } } @@ -1470,32 +1467,32 @@ } void RexxActivation::setDigits( - long digits) /* new digits setting */ + long digitsVal) /* new digits setting */ /******************************************************************************/ /* Function: Set a new digits setting */ /******************************************************************************/ { - this->settings.global_settings.digits = digits; + this->settings.global_settings.digits = digitsVal; } void RexxActivation::setFuzz( - long fuzz) /* set a new FUZZ setting */ + long fuzzVal) /* set a new FUZZ setting */ /******************************************************************************/ /* Function: Set a new FUZZ setting */ /******************************************************************************/ { - this->settings.global_settings.fuzz = fuzz; + this->settings.global_settings.fuzz = fuzzVal; } void RexxActivation::setForm( - BOOL form) /* the new FORM setting */ + BOOL formVal) /* the new FORM setting */ /******************************************************************************/ /* Function: Set the new current NUMERIC FORM setting */ /******************************************************************************/ { - this->settings.global_settings.form = form; + this->settings.global_settings.form = formVal; } @@ -1669,8 +1666,8 @@ void RexxActivation::mergeTraps( - RexxQueue * condition_queue, /* previous condition queue */ - RexxQueue * handler_queue ) /* current condition handlers queue */ + RexxQueue * source_condition_queue, /* previous condition queue */ + RexxQueue * source_handler_queue ) /* current condition handlers queue */ /******************************************************************************/ /* Function: Merge a list of trapped conditions from an interpret into the */ /* parent activation's queues. */ @@ -1678,22 +1675,22 @@ { LONG items; /* number of items to merge */ - if (condition_queue != OREF_NULL) { /* have something to add? */ + if (source_condition_queue != OREF_NULL) { /* have something to add? */ /* no condition queue yet? */ if (this->condition_queue == OREF_NULL) { /* just copy over */ - this->condition_queue = condition_queue; + this->condition_queue = source_condition_queue; /* ...both queues */ - this->handler_queue = handler_queue; + this->handler_queue = source_handler_queue; } else { /* get the item count */ - items = condition_queue->getSize(); + items = source_condition_queue->getSize(); while (items--) { /* while more items */ /* add to the end of the queue */ - this->handler_queue->addLast(handler_queue->pullRexx()); + this->handler_queue->addLast(source_handler_queue->pullRexx()); /* move condition object to the end */ - this->condition_queue->addLast(condition_queue->pullRexx()); + this->condition_queue->addLast(source_condition_queue->pullRexx()); } } /* reset the counter size */ @@ -1728,14 +1725,14 @@ /* Function: Retrieve the activation that activated this activation (whew) */ /******************************************************************************/ { - RexxActivation *sender; /* sender activation */ + RexxActivation *_sender; /* sender activation */ /* get the sender from the activity */ - sender = (RexxActivation *)this->getSender(); + _sender = (RexxActivation *)this->getSender(); /* spin down to non-native activation*/ - while (sender != (RexxActivation *)TheNilObject && OTYPE(NativeActivation,sender)) - sender = (RexxActivation *)sender->getSender(); - return sender; /* return that activation */ + while (_sender != (RexxActivation *)TheNilObject && OTYPE(NativeActivation,sender)) + _sender = (RexxActivation *)_sender->getSender(); + return _sender; /* return that activation */ } void RexxActivation::interpret( @@ -1747,7 +1744,7 @@ { RexxMethod * newMethod; /* new method to process */ RexxActivation * newActivation; /* new activation for call */ - RexxObject * result; + RexxObject * resultObj; this->activity->stackSpace(); /* perform a stack space check */ /* translate the code */ @@ -1757,8 +1754,8 @@ this->activity->push(newActivation); /* push on the activity stack */ /* run the internal routine on the */ /* new activation */ - result = newActivation->run(arglist, argcount, OREF_NULL); - if (result != OREF_NULL) discard(result); + resultObj = newActivation->run(arglist, argcount, OREF_NULL); + if (resultObj != OREF_NULL) discard(resultObj); } @@ -1771,7 +1768,7 @@ RexxMethod * newMethod; /* new method to process */ RexxActivation * newActivation; /* new activation for call */ jmp_buf previous_jump; /* target error handler */ - RexxObject * result; + RexxObject * resultObj; /* save previous jump handler */ memcpy(&previous_jump, &this->conditionjump, sizeof(jmp_buf)); @@ -1796,8 +1793,8 @@ this->activity->push(newActivation); /* push on the activity stack */ /* run the internal routine on the */ /* new activation */ - result = newActivation->run(arglist, argcount, OREF_NULL); - if (result != OREF_NULL) discard(result); + resultObj = newActivation->run(arglist, argcount, OREF_NULL); + if (resultObj != OREF_NULL) discard(resultObj); if (this->activity->nestedInfo.exitset && this->settings.dbg_flags&dbg_trace) this->debug_pause = FALSE; /* no longer in debug */ @@ -1809,19 +1806,16 @@ /* Function: Retrieve a REXX defined "dot" environment variable */ /******************************************************************************/ { - RexxObject * result; /* command return code */ - result = OREF_NULL; /* default to unknown */ - if (name->strCompare(CHAR_METHODS)) {/* is this ".methods" */ /* get the methods directory */ - result = (RexxObject *)this->settings.parent_source->getMethods(); + return (RexxObject *)this->settings.parent_source->getMethods(); } else if (name->strCompare(CHAR_RS)) {/* command return status (".rs")? */ if (this->settings.flags&return_status_set) /* returned as an integer object */ - result = new_integer(this->settings.return_status); + return new_integer(this->settings.return_status); else /* just return the name */ - result = name->concatToCstring("."); + return name->concatToCstring("."); } else if (name->strCompare(CHAR_LINE)) /* current line (".line")? */ { @@ -1829,53 +1823,53 @@ // the context that calls the interpret. if (this->activation_context == INTERPRET) { - result = sender->rexxVariable(name); + return sender->rexxVariable(name); } else { - result = new_integer(this->current->getLine()); + return new_integer(this->current->getLine()); } } - return result; /* return the result */ + return OREF_NULL; // not recognized } RexxObject * RexxActivation::externalCall( RexxString * target, /* target of the call */ - size_t argcount, /* count of arguments */ - RexxExpressionStack * stack, /* stack of arguments */ + size_t _argcount, /* count of arguments */ + RexxExpressionStack * _stack, /* stack of arguments */ RexxString * calltype ) /* FUNCTION or ROUTINE */ /******************************************************************************/ /* Function: Process an external function call */ /******************************************************************************/ { RexxMethod * routine; /* resolved call pointer */ - RexxObject * result; /* command return code */ - RexxObject **arguments; /* argument array */ + RexxObject * resultObj; /* command return code */ + RexxObject **_arguments; /* argument array */ BOOL found; routine = OREF_NULL; /* set not found condition */ /* get the arguments array */ - arguments = stack->arguments(argcount); + _arguments = _stack->arguments(_argcount); /* see if we have a ::ROUTINE here */ routine = this->settings.parent_source->resolveRoutine(target); if (routine == OREF_NULL) { /* still not found? */ /* if exit declines call */ - if (this->activity->sysExitFunc(this, target, calltype, &result, arguments, argcount)) { + if (this->activity->sysExitFunc(this, target, calltype, &resultObj, _arguments, _argcount)) { /* exist in functions definition? */ routine = (RexxMethod *)TheFunctionsDirectory->get(target); if (routine == OREF_NULL) /* not found yet? */ { /* do external search and execute */ - result = SysExternalFunction(this, this->activity, target, - this->code->getProgramName(), arguments, argcount, calltype, &found); + resultObj = SysExternalFunction(this, this->activity, target, + this->code->getProgramName(), _arguments, _argcount, calltype, &found); #ifdef SCRIPTING if (!found) { char newCalltype[32] = "AX"; sprintf(newCalltype+2,"%p",calltype); // store info that is is called in engine // context, also store calltype information - found = !this->activity->sysExitFunc(this, target, new_cstring(newCalltype), &result, arguments, argcount); + found = !this->activity->sysExitFunc(this, target, new_cstring(newCalltype), &resultObj, _arguments, _argcount); //if (found) // result = routine->call(this->activity, (RexxObject *)this, target, arguments, calltype, OREF_NULL, EXTERNALCALL); } @@ -1886,29 +1880,29 @@ if (routine == OREF_NULL) /* not found yet? */ report_exception1(Error_Routine_not_found_name, target); else - result = routine->call(this->activity, (RexxObject *)this, target, arguments, argcount, calltype, OREF_NULL, EXTERNALCALL); + resultObj = routine->call(this->activity, (RexxObject *)this, target, _arguments, _argcount, calltype, OREF_NULL, EXTERNALCALL); } } else /* we found a routine so run it */ /* run a special way */ - result = routine->call(this->activity, (RexxObject *)this, target, arguments, argcount, calltype, OREF_NULL, EXTERNALCALL); + resultObj = routine->call(this->activity, (RexxObject *)this, target, _arguments, _argcount, calltype, OREF_NULL, EXTERNALCALL); } } else /* we found a routine so run it */ /* run a special way */ - result = routine->call(this->activity, (RexxObject *)this, target, arguments, argcount, calltype, OREF_NULL, EXTERNALCALL); - return result; /* return the function result */ + resultObj = routine->call(this->activity, (RexxObject *)this, target, _arguments, _argcount, calltype, OREF_NULL, EXTERNALCALL); + return resultObj; /* return the function result */ } BOOL RexxActivation::callExternalRexx( RexxString * target, /* Name of external function */ RexxString * parent, /* name of the parent file */ - RexxObject ** arguments, /* Argument array */ - size_t argcount, /* number of arguments in the call */ + RexxObject ** _arguments, /* Argument array */ + size_t _argcount, /* number of arguments in the call */ RexxString * calltype, /* Type of call */ - RexxObject ** result ) /* Result of function call */ + RexxObject ** resultObj) /* Result of function call */ /******************************************************************************/ /* Function: Call a rexx protram as an external routine */ /******************************************************************************/ @@ -1934,7 +1928,7 @@ else { /* Try to run method */ save(routine); /* run as a call */ - *result = routine->call(this->activity, (RexxObject *)this, target, arguments, argcount, calltype, this->settings.current_env, EXTERNALCALL); + *resultObj = routine->call(this->activity, (RexxObject *)this, target, _arguments, _argcount, calltype, this->settings.current_env, EXTERNALCALL); /* now merge all of the public info */ this->settings.parent_source->mergeRequired(routine->code->u_source); discard(routine); @@ -1954,9 +1948,9 @@ /******************************************************************************/ { RexxString * fullname = OREF_NULL;/* fully resolved install name */ - RexxMethod * method = OREF_NULL; /* method to invoke */ - RexxDirectory * securityArgs; /* security check arguments */ - RexxObject * result; + RexxMethod * _method = OREF_NULL; /* method to invoke */ + RexxDirectory * securityArgs = OREF_NULL; /* security check arguments */ + RexxObject * resultObj; USHORT usMacroPosition; /* macro search order */ BOOL fFileExists = TRUE; /* does required file exist */ BOOL fMacroExists = FALSE;/* does required macro exist */ @@ -2006,52 +2000,52 @@ /* first see if we have something in macrospace with this name */ if (fMacroExists && (usMacroPosition == RXMACRO_SEARCH_BEFORE)) - method = SysGetMacroCode(target); + _method = SysGetMacroCode(target); /* if not in PRE macrospace search order, try to load a file */ - if (fFileExists && (method == OREF_NULL)) + if (fFileExists && (_method == OREF_NULL)) { - method = SysRestoreProgram(fullname);/* try to restore saved image */ - if (method == OREF_NULL) { /* unable to restore? */ + _method = SysRestoreProgram(fullname);/* try to restore saved image */ + if (_method == OREF_NULL) { /* unable to restore? */ /* go translate the image */ - method = TheMethodClass->newFile(fullname); - SysSaveProgram(fullname, method); /* go save this method */ + _method = TheMethodClass->newFile(fullname); + SysSaveProgram(fullname, _method); /* go save this method */ } } /* if still not found try to load POST macro */ - if ((method == OREF_NULL) && fMacroExists) - method = SysGetMacroCode(target); + if ((_method == OREF_NULL) && fMacroExists) + _method = SysGetMacroCode(target); - if (method == OREF_NULL) /* couldn't create this? */ + if (_method == OREF_NULL) /* couldn't create this? */ /* report an error */ report_exception1(Error_Routine_not_found_requires, target); /* Indicate this routine is being */ /*installed */ - save(method); + save(_method); this->activity->addRunningRequires(fullname); if (this->hasSecurityManager()) { - result = securityArgs->fastAt(new_cstring(CHAR_SECURITYMANAGER)); - if (result && result != TheNilObject) - method->setSecurityManager(result); + resultObj = securityArgs->fastAt(new_cstring(CHAR_SECURITYMANAGER)); + if (resultObj != OREF_NULL && resultObj != TheNilObject) + _method->setSecurityManager(resultObj); } this->stack.pop(); /* now remove the protection */ /* run a special way */ - result = method->call(this->activity, (RexxObject *)this, target, NULL, 0, OREF_ROUTINENAME, OREF_NULL, EXTERNALCALL); - if ((result != OREF_NULL) && method->isRexxMethod()) discard(result); + resultObj = _method->call(this->activity, (RexxObject *)this, target, NULL, 0, OREF_ROUTINENAME, OREF_NULL, EXTERNALCALL); + if ((resultObj != OREF_NULL) && _method->isRexxMethod()) discard(resultObj); /* No longer installing routine. */ this->activity->removeRunningRequires(fullname); /* now merge all of the info */ this->settings.parent_source->mergeRequired(method->code->u_source); - discard(method); - return method; /* return the method (but not needed!) */ + discard(_method); + return _method; /* return the method (but not needed!) */ } RexxObject * RexxActivation::internalCall( RexxInstruction *target, /* target of the call */ - size_t argcount, /* count of arguments */ - RexxExpressionStack *stack ) /* stack of arguments */ + size_t _argcount, /* count of arguments */ + RexxExpressionStack *_stack ) /* stack of arguments */ /******************************************************************************/ /* Function: Process an internal function or subroutine call */ /******************************************************************************/ @@ -2059,7 +2053,7 @@ RexxActivation * newActivation; /* new activation for call */ long lineNum; /* line number of the call */ RexxObject * returnObject; - RexxObject ** arguments = stack->arguments(argcount); + RexxObject ** _arguments = _stack->arguments(_argcount); lineNum = this->current->getLine(); /* get the current line number */ /* initialize the SIGL variable */ @@ -2073,7 +2067,7 @@ /* new activation */ newActivation->dbgDisableStepOver(); dbgEnterSubroutine(); - returnObject = newActivation->run(arguments, argcount, target); + returnObject = newActivation->run(_arguments, _argcount, target); dbgLeaveSubroutine(); newActivation->dbgPassTrace2Parent(this); return returnObject; @@ -2162,12 +2156,12 @@ /* Function: Add the activation's current line to an error trace back list */ /******************************************************************************/ { - RexxSource * source; /* current method source */ + RexxSource * _source; /* current method source */ RexxString * line; /* traceback line */ - source = this->code->u_source; /* get the source object */ - if (source->traceable()) { /* if we still have real source */ - line = this->formatTrace(this->current, source); + _source = this->code->u_source; /* get the source object */ + if (_source->traceable()) { /* if we still have real source */ + line = this->formatTrace(this->current, _source); if (line != OREF_NULL) /* have a real line? */ traceback_list->addLast(line); /* add the next traceback item */ } @@ -2426,7 +2420,7 @@ } // get the string value from the traced object. - RexxString *stringValue = value->stringValue(); + RexxString *stringVal = value->stringValue(); // protect against negative indent values (belt and braces) if (this->settings.traceindent < 0) { @@ -2435,7 +2429,7 @@ } // now calculate the length of the traced string - stringsize_t outLength = tag->getLength() + stringValue->getLength(); + stringsize_t outLength = tag->getLength() + stringVal->getLength(); // these are fixed overheads outLength += TRACE_OVERHEAD + strlen(VALUE_MARKER); // now the indent spacing @@ -2490,8 +2484,8 @@ dataOffset++; // the traced value - buffer->put(dataOffset, stringValue); - dataOffset += stringValue->getLength(); + buffer->put(dataOffset, stringVal); + dataOffset += stringVal->getLength(); // and finally, the trailing quote buffer->putChar(dataOffset, '\"'); @@ -2525,7 +2519,7 @@ } // get the string value from the traced object. - RexxString *stringValue = value->stringValue(); + RexxString *stringVal = value->stringValue(); // protect against negative indent values (belt and braces) if (this->settings.traceindent < 0) { @@ -2534,7 +2528,7 @@ } // now calculate the length of the traced string - stringsize_t outLength = strlen(tag) + stringValue->getLength(); + stringsize_t outLength = strlen(tag) + stringVa... [truncated message content] |
From: <bi...@us...> - 2007-10-27 18:00:18
|
Revision: 1105 http://oorexx.svn.sourceforge.net/oorexx/?rev=1105&view=rev Author: bigrixx Date: 2007-10-27 11:00:22 -0700 (Sat, 27 Oct 2007) Log Message: ----------- More warnings work. Modified Paths: -------------- sandbox/rick/warnings2/kernel/classes/MethodClass.cpp sandbox/rick/warnings2/kernel/classes/ObjectClass.cpp sandbox/rick/warnings2/kernel/classes/ObjectClass.hpp sandbox/rick/warnings2/kernel/classes/StringClass.cpp sandbox/rick/warnings2/kernel/classes/TableClass.cpp sandbox/rick/warnings2/kernel/classes/TableClass.hpp sandbox/rick/warnings2/kernel/parser/SourceFile.cpp sandbox/rick/warnings2/kernel/runtime/RexxActivity.cpp sandbox/rick/warnings2/kernel/runtime/RexxCompoundElement.cpp sandbox/rick/warnings2/kernel/runtime/RexxCore.h sandbox/rick/warnings2/kernel/runtime/RexxEnvelope.cpp sandbox/rick/warnings2/kernel/runtime/RexxEnvelope.hpp sandbox/rick/warnings2/kernel/runtime/RexxMemory.cpp sandbox/rick/warnings2/kernel/runtime/Setup.cpp Modified: sandbox/rick/warnings2/kernel/classes/MethodClass.cpp =================================================================== --- sandbox/rick/warnings2/kernel/classes/MethodClass.cpp 2007-10-27 16:38:53 UTC (rev 1104) +++ sandbox/rick/warnings2/kernel/classes/MethodClass.cpp 2007-10-27 18:00:22 UTC (rev 1105) @@ -482,7 +482,7 @@ /* now pack up the envelope for */ /* saving. */ - envelope->pack(OREF_NULL, this, OREF_NULL, OREF_NULL); + envelope->pack(this); /* pull out the buffer */ envelopeBuffer = envelope->getBuffer(); discard(hold(envelope)); /* release memory lock on envelope */ Modified: sandbox/rick/warnings2/kernel/classes/ObjectClass.cpp =================================================================== --- sandbox/rick/warnings2/kernel/classes/ObjectClass.cpp 2007-10-27 16:38:53 UTC (rev 1104) +++ sandbox/rick/warnings2/kernel/classes/ObjectClass.cpp 2007-10-27 18:00:22 UTC (rev 1105) @@ -1546,58 +1546,6 @@ return newMessage; /* return the new message object */ } -RexxEnvelope*RexxObject::startAt(RexxObject **args, size_t argCount) -/****************************************************************************/ -/* Function: Flatten and run a method "elsewhere" */ -/****************************************************************************/ -{ - RexxEnvelope *envelope; - RexxSmartBuffer *envelopeBuffer; - RexxBuffer *buffer; - PVOID data; - RexxString *location; - RexxString *message; - RexxArray *arguments; - long bufferLength; - - FILE *dumpfile; - - /* Get new envelope object */ - envelope = (RexxEnvelope *)save(new_envelope()); - - /* now break apart args, no error */ - /* checking now, will come later */ - /* Where are we going? */ - location = (RexxString *)args[0]; - /* what message are we sending? */ - message = (RexxString *)args[1]; - /* all remaining args are arguments */ - /* to the message, so get rest into */ - /* and array. */ - arguments = new (argCount - 2, args + 2) RexxArray; - - /* now pack up the envelope for send */ - /* to remote system, the receiver is */ - /* ourself */ - envelope->pack(location, this, message, arguments); - - /* ******************************************************************************** */ - /* *** Temporary - Just dump object to a file for now. *** */ - /* ******************************************************************************** */ - /* get the smartbuffer */ - envelopeBuffer = envelope->getBuffer(); - buffer = envelopeBuffer->getBuffer();/* get the buffer */ - data = (PVOID)buffer->data; /* get the address */ - dumpfile = fopen("flatten.obj","wb");/* open for binary write */ - bufferLength = (long)envelopeBuffer->current; - /* Write in te size of buffer */ - fwrite((PVOID)&bufferLength, 1, sizeof(bufferLength), dumpfile); - /* NOW WRITE IN ENTIRE BUFFER */ - fwrite((PVOID)data, 1, bufferLength, dumpfile); - fclose(dumpfile); - return envelope; /* Temp for now ... */ -} - RexxString *RexxObject::oref() /****************************************************************************/ /* Function: Return the objects address as a HEX string (debugging only) */ Modified: sandbox/rick/warnings2/kernel/classes/ObjectClass.hpp =================================================================== --- sandbox/rick/warnings2/kernel/classes/ObjectClass.hpp 2007-10-27 16:38:53 UTC (rev 1104) +++ sandbox/rick/warnings2/kernel/classes/ObjectClass.hpp 2007-10-27 18:00:22 UTC (rev 1105) @@ -234,7 +234,6 @@ RexxObject *unsetMethod(RexxString *); RexxObject *requestRexx(RexxString *); RexxMessage *start(RexxObject **, size_t); - RexxEnvelope*startAt(RexxObject **, size_t); RexxString *oref(); RexxObject *pmdict(); RexxObject *shriekRun(RexxMethod *, RexxString *, RexxString *, RexxObject **, size_t); Modified: sandbox/rick/warnings2/kernel/classes/StringClass.cpp =================================================================== --- sandbox/rick/warnings2/kernel/classes/StringClass.cpp 2007-10-27 16:38:53 UTC (rev 1104) +++ sandbox/rick/warnings2/kernel/classes/StringClass.cpp 2007-10-27 18:00:22 UTC (rev 1105) @@ -109,22 +109,15 @@ /* Function: unflatten an object */ /******************************************************************************/ { - RexxObject *newSelf; - if (this->header & ProxyObject) { /* is this a proxy object? */ - /* Yes, then we need to run the code */ - /* to generate a new object */ - newSelf = envelope->queryProxy(this); - if (!newSelf) { /* not in the table? */ - /* get the proxy from the environment */ - newSelf = TheEnvironment->entry(this); - /* and add to the proxy table */ - envelope->addProxy(this, newSelf); - } + // just perform an environment lookup + return TheEnvironment->entry(this); } else - newSelf = this->RexxObject::unflatten(envelope); - return newSelf; /* return the new version */ + { + // perform a normal default unflatten op. + return this->RexxObject::unflatten(envelope); + } } RexxString *RexxString::stringValue() Modified: sandbox/rick/warnings2/kernel/classes/TableClass.cpp =================================================================== --- sandbox/rick/warnings2/kernel/classes/TableClass.cpp 2007-10-27 16:38:53 UTC (rev 1104) +++ sandbox/rick/warnings2/kernel/classes/TableClass.cpp 2007-10-27 18:00:22 UTC (rev 1105) @@ -48,7 +48,7 @@ #include "RexxNativeAPI.h" RexxObject *RexxTable::addOffset( - RexxObject *_value, /* object to add */ + size_t _value, /* object to add */ RexxObject *_index) /* added index */ /******************************************************************************/ /* Function: This add method is used by the envelope packing/copybuffer */ @@ -64,7 +64,7 @@ memoryObject.disableOrefChecks(); /* Turn off OrefSet Checking. */ /* try to place in existing hashtab */ - newHash = this->contents->primitiveAdd(_value, _index); + newHash = this->contents->primitiveAdd((RexxObject *)_value, _index); if (newHash != OREF_NULL) { /* have a reallocation occur? */ /* mark the hash as not having refere*/ /* even though the indices are objs */ Modified: sandbox/rick/warnings2/kernel/classes/TableClass.hpp =================================================================== --- sandbox/rick/warnings2/kernel/classes/TableClass.hpp 2007-10-27 16:38:53 UTC (rev 1104) +++ sandbox/rick/warnings2/kernel/classes/TableClass.hpp 2007-10-27 18:00:22 UTC (rev 1105) @@ -58,7 +58,7 @@ RexxObject * putNodupe(RexxObject *, RexxObject *); RexxObject * stringPut(RexxObject *, RexxString *); RexxObject * stringAdd(RexxObject *, RexxString *); - RexxObject * addOffset(RexxObject *, RexxObject *); + RexxObject * addOffset(size_t, RexxObject *); RexxObject * replace(RexxObject *newValue, long pos) {return this->contents->replace(newValue, pos); }; RexxArray * allAt(RexxObject *key) { return this->contents->getAll(key); } void reHash(); Modified: sandbox/rick/warnings2/kernel/parser/SourceFile.cpp =================================================================== --- sandbox/rick/warnings2/kernel/parser/SourceFile.cpp 2007-10-27 16:38:53 UTC (rev 1104) +++ sandbox/rick/warnings2/kernel/parser/SourceFile.cpp 2007-10-27 18:00:22 UTC (rev 1105) @@ -558,15 +558,10 @@ /* don't need to to keep source info */ /* so ask the envelope if this is a */ /* flatten to save the method image */ - if (METHOD_ENVELOPE == envelope->queryType()) { - /* Yes it is, so don't flatten the */ - /* source image. */ - this->sourceArray = OREF_NULL; - this->sourceBuffer = OREF_NULL; - this->sourceIndices = OREF_NULL; - this->securityManager = OREF_NULL; - this->flags &= ~reclaim_possible;/* can't recover the source immediately*/ - } + this->sourceArray = OREF_NULL; + this->sourceBuffer = OREF_NULL; + this->sourceIndices = OREF_NULL; + this->securityManager = OREF_NULL; flatten_reference(newThis->sourceArray, envelope); flatten_reference(newThis->programName, envelope); flatten_reference(newThis->clause, envelope); Modified: sandbox/rick/warnings2/kernel/runtime/RexxActivity.cpp =================================================================== --- sandbox/rick/warnings2/kernel/runtime/RexxActivity.cpp 2007-10-27 16:38:53 UTC (rev 1104) +++ sandbox/rick/warnings2/kernel/runtime/RexxActivity.cpp 2007-10-27 18:00:22 UTC (rev 1105) @@ -1208,7 +1208,7 @@ { RexxActivationBase *top_activation; /* removed activation */ RexxActivationBase *old_activation; /* removed activation */ - RexxActivationBase *currentAct = OREF_NULL; /* current loop activation */ + RexxActivationBase *tempAct = OREF_NULL; /* current loop activation */ RexxInternalStack *activationStack; /* activation stack */ size_t i; /* loop counter */ @@ -1237,12 +1237,12 @@ /* clear this out */ old_activation = (RexxActivationBase *)TheNilObject; /* spin down the stack */ - for (i = 0; currentAct != (RexxActivationBase *)TheNilObject && i < this->depth; i++) { + for (i = 0; tempAct != (RexxActivationBase *)TheNilObject && i < this->depth; i++) { /* get the next item */ - currentAct = (RexxActivationBase *)activationStack->peek(i); + tempAct = (RexxActivationBase *)activationStack->peek(i); /* find a REXX one? */ - if (OTYPE(Activation, currentAct)) { - old_activation = currentAct; /* save this one */ + if (OTYPE(Activation, tempAct)) { + old_activation = tempAct; /* save this one */ break; /* and exit the loop */ } } @@ -1276,7 +1276,7 @@ /******************************************************************************/ { RexxActivationBase *old_activation; /* removed activation */ - RexxActivationBase *currentAct = OREF_NULL; /* current loop activation, */ + RexxActivationBase *tempAct = OREF_NULL; /* current loop activation, */ RexxInternalStack *activationStack; /* activation stack */ size_t i; /* loop counter */ @@ -1300,12 +1300,12 @@ /* clear this out */ old_activation = (RexxActivationBase *)TheNilObject; /* spin down the stack */ - for (i = 0; currentAct != (RexxActivationBase *)TheNilObject && i < this->depth; i++) { + for (i = 0; tempAct != (RexxActivationBase *)TheNilObject && i < this->depth; i++) { /* get the next item */ - currentAct = (RexxActivationBase *)activationStack->peek(i); + tempAct = (RexxActivationBase *)activationStack->peek(i); /* find a REXX one? */ - if (OTYPE(Activation, currentAct)) { - old_activation = currentAct; /* save this one */ + if (OTYPE(Activation, tempAct)) { + old_activation = tempAct; /* save this one */ break; /* and exit the loop */ } } @@ -2759,7 +2759,7 @@ void RexxActivityClass::addWaitingActivity( - RexxActivity *waitingActivity, /* new activity to add to the queue */ + RexxActivity *waitingAct, /* new activity to add to the queue */ BOOL release ) /* need to release the run semaphore */ /******************************************************************************/ /* Function: Add an activity to the round robin wait queue */ @@ -2776,22 +2776,22 @@ /* nobody waiting yet? */ if (this->firstWaitingActivity == OREF_NULL) { /* this is the head of the chain */ - this->firstWaitingActivity = waitingActivity; + this->firstWaitingActivity = waitingAct; /* and the tail */ - this->lastWaitingActivity = waitingActivity; + this->lastWaitingActivity = waitingAct; SysExitResourceSection(); /* end of the critical section */ } else { /* move to the end of the line */ /* chain off of the existing one */ - this->lastWaitingActivity->setNextWaitingActivity(waitingActivity); + this->lastWaitingActivity->setNextWaitingActivity(waitingAct); /* this is the new last one */ - this->lastWaitingActivity = waitingActivity; - waitingActivity->clearWait(); /* clear the run semaphore */ + this->lastWaitingActivity = waitingAct; + waitingAct->clearWait(); /* clear the run semaphore */ SysExitResourceSection(); /* end of the critical section */ if (release) /* current semaphore owner? */ MTXRL(kernel_semaphore); /* release the lock */ SysThreadYield(); /* yield the thread */ - waitingActivity->waitKernel(); /* and wait for permission */ + waitingAct->waitKernel(); /* and wait for permission */ } MTXRQ(kernel_semaphore); /* request the lock now */ SysEnterResourceSection(); /* now remove the waiting one */ @@ -2816,7 +2816,7 @@ before and therefore we can set next pointer to NULL without disturbing the linked list */ - waitingActivity->setNextWaitingActivity(OREF_NULL); + waitingAct->setNextWaitingActivity(OREF_NULL); /* was this the only one? */ if (!this->firstWaitingActivity) { @@ -2827,9 +2827,9 @@ { this->firstWaitingActivity->postRelease(); } - CurrentActivity = waitingActivity; /* set new current activity */ + CurrentActivity = waitingAct; /* set new current activity */ /* and new active settings */ - current_settings = waitingActivity->settings; + current_settings = waitingAct->settings; SysExitResourceSection(); /* end of the critical section */ /* have more pools been added since */ /* we left the kernel ? */ Modified: sandbox/rick/warnings2/kernel/runtime/RexxCompoundElement.cpp =================================================================== --- sandbox/rick/warnings2/kernel/runtime/RexxCompoundElement.cpp 2007-10-27 16:38:53 UTC (rev 1104) +++ sandbox/rick/warnings2/kernel/runtime/RexxCompoundElement.cpp 2007-10-27 18:00:22 UTC (rev 1105) @@ -103,20 +103,20 @@ /****************************************************************************/ { /* created variable object */ - RexxCompoundElement *newObject; + RexxCompoundElement *newObj; /* Get new object */ - newObject = (RexxCompoundElement *)new_object(sizeof(RexxCompoundElement)); + newObj = (RexxCompoundElement *)new_object(sizeof(RexxCompoundElement)); /* Give new object its behaviour */ - BehaviourSet(newObject, TheCompoundElementBehaviour); + BehaviourSet(newObj, TheCompoundElementBehaviour); /* set the virtual function table */ - setVirtualFunctions(newObject, T_compound_element); + setVirtualFunctions(newObj, T_compound_element); /* Explicitly clear out the variable value, which is not cleared */ /* by ClearObject call. Note that we don't use OREF_SET here, as */ /* this field is likely to be garbage. */ - newObject->variableValue = OREF_NULL; - ClearObject(newObject); /* clear everything out */ - newObject->variable_name = name; /* fill in the name */ + newObj->variableValue = OREF_NULL; + ClearObject(newObj); /* clear everything out */ + newObj->variable_name = name; /* fill in the name */ - return newObject; /* return the new object */ + return newObj; /* return the new object */ } Modified: sandbox/rick/warnings2/kernel/runtime/RexxCore.h =================================================================== --- sandbox/rick/warnings2/kernel/runtime/RexxCore.h 2007-10-27 16:38:53 UTC (rev 1104) +++ sandbox/rick/warnings2/kernel/runtime/RexxCore.h 2007-10-27 18:00:22 UTC (rev 1105) @@ -366,9 +366,6 @@ EXTERN RexxClass * TheArrayClass INITGLOBALPTR; /* array class */ EXTERN RexxClass * TheClassClass INITGLOBALPTR; /* class of classes */ EXTERN RexxClass * TheDirectoryClass INITGLOBALPTR; /* directory class */ - /* envelope class - for mobile */ - /*objects */ -EXTERN RexxClass * TheEnvelopeClass INITGLOBALPTR; EXTERN RexxDirectory * TheEnvironment INITGLOBALPTR; /* environment object */ EXTERN RexxDirectory * ThePublicRoutines INITGLOBALPTR; /* public_routines directory */ @@ -630,7 +627,6 @@ #define TheDirectoryBehaviour ((RexxBehaviour *)(&pbehav[T_directory])) #define TheDirectoryClassBehaviour ((RexxBehaviour *)(&pbehav[T_directory_class])) #define TheEnvelopeBehaviour ((RexxBehaviour *)(&pbehav[T_envelope])) -#define TheEnvelopeClassBehaviour ((RexxBehaviour *)(&pbehav[T_envelope_class])) #define TheHashTableBehaviour ((RexxBehaviour *)(&pbehav[T_hashtab])) #define TheIntegerBehaviour ((RexxBehaviour *)(&pbehav[T_integer])) #define TheIntegerClassBehaviour ((RexxBehaviour *)(&pbehav[T_integer_class])) Modified: sandbox/rick/warnings2/kernel/runtime/RexxEnvelope.cpp =================================================================== --- sandbox/rick/warnings2/kernel/runtime/RexxEnvelope.cpp 2007-10-27 16:38:53 UTC (rev 1104) +++ sandbox/rick/warnings2/kernel/runtime/RexxEnvelope.cpp 2007-10-27 18:00:22 UTC (rev 1105) @@ -75,11 +75,7 @@ { setUpMemoryMark memory_mark(this->home); - memory_mark(this->destination); memory_mark(this->receiver); - memory_mark(this->message); - memory_mark(this->arguments); - memory_mark(this->result); memory_mark(this->duptable); memory_mark(this->savetable); memory_mark(this->buffer); @@ -98,11 +94,7 @@ { setUpMemoryMarkGeneral memory_mark_general(this->home); - memory_mark_general(this->destination); memory_mark_general(this->receiver); - memory_mark_general(this->message); - memory_mark_general(this->arguments); - memory_mark_general(this->result); memory_mark_general(this->duptable); memory_mark_general(this->savetable); memory_mark_general(this->buffer); @@ -120,42 +112,23 @@ setUpFlatten(RexxEnvelope) flatten_reference(newThis->home, envelope); - flatten_reference(newThis->destination, envelope); flatten_reference(newThis->receiver, envelope); - flatten_reference(newThis->message, envelope); - flatten_reference(newThis->arguments, envelope); - flatten_reference(newThis->result, envelope); flatten_reference(newThis->rehashtable, envelope); flatten_reference(newThis->objectVariables, envelope); - /* following if test determines if this */ - /* envelope is the top level, or if the */ - /* envelope is actually part of another */ -#ifdef NESTED - if (envelope == this) { -#endif - /* Top level envelope, no need to send */ - this->buffer = OREF_NULL; /* dupTable or smartbuffer, useless on */ - /* other side ... */ + /* following if test determines if this */ + /* envelope is the top level, or if the */ + /* envelope is actually part of another */ + /* Top level envelope, no need to send */ + this->buffer = OREF_NULL; /* dupTable or smartbuffer, useless on */ + /* other side ... */ - /* Special self reference so that we get*/ - /* Marked (SetLive) correctly during the*/ - /* unpacking of the envelope on the */ - /* remote system */ - /* compute our offset. */ - this->duptable = (RexxObjectTable *)((PCHAR)this - envelope->bufferStart()); - -#ifdef NESTED - } else { -#endif - /* Part of a greater envelope, we need */ - /* all our buffer information. but not */ - /* the table. */ -#ifdef NESTED - flatten_reference(this->buffer, envelope); - this->duptable = OREF_NULL; - } -#endif + /* Special self reference so that we get*/ + /* Marked (SetLive) correctly during the*/ + /* unpacking of the envelope on the */ + /* remote system */ + /* compute our offset. */ + this->duptable = (RexxObjectTable *)((char *)this - envelope->bufferStart()); cleanUpFlatten } @@ -167,226 +140,188 @@ return this; /* this does nothing */ } + void RexxEnvelope::flattenReference( void *newThisVoid, /* current pointer to flattening obj */ - LONG newSelf, /* offset of the flattening object */ + size_t newSelf, /* offset of the flattening object */ void *objRefVoid) /* object to process */ /******************************************************************************/ /* Function: This method does the copy buffer, */ /******************************************************************************/ { - RexxObject **newThis = (RexxObject **)newThisVoid; - RexxObject **objRef = (RexxObject **)objRefVoid; + RexxObject **newThis = (RexxObject **)newThisVoid; + RexxObject **objRef = (RexxObject **)objRefVoid; - RexxObject *newObj; /* new object in buffer */ - RexxObject *obj = *objRef; /* get working pointer to object */ - RexxObject *proxyObj; /* proxy of the flattened object */ - long referenceOffset; /* offset of the reference */ - PCHAR buffer; /* buffer location */ - PCHAR newBuffer; /* location after a copy operation */ + RexxObject *obj = *objRef; /* get working pointer to object */ - /* See if object has already been */ - newObj = this->queryObj(obj); /* Flattened/proxied. */ - if (!newObj) { - buffer = this->bufferStart(); /* get the entry buffer location */ - /* not known, is this a proxy? */ - /* compute actual off to be updated */ - /* since buffer may have to grow */ - /* we cannot rely on a address */ - referenceOffset = (ULONG)objRef - (ULONG)buffer; + /* See if object has already been */ + size_t objOffset = this->queryObj(obj); /* flattened. */ + // if this object has not been previously flattened, we need to + // copy the object into the buffer and add the offset to the table. + if (objOffset == 0) + { + // this is the sart of the buffer + char *flattenBuffer = this->bufferStart(); + // this is the offset to the reference we're working with. If the + // buffer needs to reallocate after a copy, we need to be able to + // locate this later + size_t referenceOffset = (char *)objRef - flattenBuffer; - if (obj->header & MakeProxyObject) {/* need to make a proxy? */ - proxyObj = obj->makeProxy(this); /* Yup. get the proxy. */ - /* protect this from garbage collection */ - savetable->put(proxyObj, proxyObj); - /* copy proxy into buffer */ - newObj = this->copyBuffer(proxyObj); - /* associate original object with */ - this->associateProxy(obj, newObj);/* flattened proxy. */ - } - else { - /* copy ourself/proxy into */ - newObj = this->copyBuffer(obj); /* buffer. */ - } - /* Disable CheckSetOREF around */ - /* The flattenStack Push */ - memoryObject.disableOrefChecks(); - /* push the new obj onto start */ - /* We'll send flatten later. */ - this->flattenStack->fastPush(newObj); - memoryObject.enableOrefChecks(); /* Enable CheckSet again. */ - newBuffer = this->bufferStart(); /* get the buffer start position */ - if (newBuffer != buffer) /* did the buffer move? */ - *newThis = (RexxObject *) (newBuffer + newSelf); - /* update reference to new obj */ - *(RexxObject **)(newBuffer + referenceOffset) = newObj; - } - else - *objRef = newObj; /* update reference to newObj offset */ + // if this is a proxied object, we need to convert it to a proxy and + // copy that object into the buffer and the reference table + if (obj->header & MakeProxyObject) + { + // get a proxy and make sure it's in our protection table + RexxObject *proxyObj = obj->makeProxy(this); + savetable->put(proxyObj, proxyObj); + + // copy the proxy to the buffer and add it to the dup table + // using the original object as the index. + objOffset = this->copyBuffer(proxyObj); + // it's not likely, but we might get a dup of the + // proxy object too. Add it to our resolution table. + this->associateObject(proxyObj, objOffset); + } + else + { + + // non-proxied object. This gets copied to the buffer + // directly and added to the dup table + objOffset = this->copyBuffer(obj); + } + // regardless of how we handle this, add an association for the object to the offset + this->associateObject(obj, objOffset); + // We're pushing an object offset on to our live stack, so we want to make sure our debug traps + // don't try to process this. + memoryObject.disableOrefChecks(); + this->flattenStack->fastPush((RexxObject *)objOffset); + memoryObject.enableOrefChecks(); + // if the buffer reallocated, we need to update the updating object pointer too. + char *newBuffer = this->bufferStart(); + if (newBuffer != flattenBuffer) + { + *newThis = (RexxObject *) (newBuffer + newSelf); + } + // and update the reference with the offset + *(RexxObject **)(newBuffer + referenceOffset) = (RexxObject *)objOffset; + } + else + { + // no copying means no reallocation...we just replace the + // original object reference with the offset value + *objRef = (RexxObject *)objOffset; + } } + RexxEnvelope *RexxEnvelope::pack( - RexxString *location, /* name of the destination */ - RexxObject *receiver, /* the receiver object */ - RexxString *message, /* the message to execute */ - RexxArray *arguments) /* message arguments */ + RexxObject *receiver) /* the receiver object */ /******************************************************************************/ /* Function: Pack an envelope item */ /******************************************************************************/ { - RexxObject *flattenObj; /* flattened object */ - RexxObject *newSelf; /* the flattened envelope */ - RexxObject *firstObject; /* first object to flatten */ - short behaviourTypeNum; /* type of flattened behaviour */ + RexxObject *flattenObj; /* flattened object */ + RexxObject *newSelf; /* the flattened envelope */ + RexxObject *firstObject; /* first object to flatten */ - OrefSet(this, this->destination, location); - OrefSet(this, this->receiver, receiver); - OrefSet(this, this->message, message); - OrefSet(this, this->arguments, arguments); - /* create a save table to protect any objects (such as proxy */ - /* objects) we create during flattening. */ - OrefSet(this, this->savetable, new_object_table()); - OrefSet(this, this->duptable, new_object_table()); - /* mark the hash table as not having */ - /*references .. */ - SetObjectHasNoReferences(this->duptable->contents); - OrefSet(this, this->buffer, new_smartbuffer()); - /* get our stack, don't use OrefSet */ - this->flattenStack = memoryObject.getFlattenStack(); - /* push unique terminator onto stack*/ - this->flattenStack->fastPush(OREF_NULL); + OrefSet(this, this->receiver, receiver); + // create a save table to protect any objects (such as proxy + // objects) we create during flattening. + OrefSet(this, this->savetable, new_object_table()); + OrefSet(this, this->duptable, new_object_table()); + // this is a bit of a hack, but necessary. This allows us to store + // object offsets into a hashtable without having the hashtable + // attempt to mark the references. + SetObjectHasNoReferences(this->duptable->contents); + OrefSet(this, this->buffer, new_smartbuffer()); + // get a flatten stack from the memory object + this->flattenStack = memoryObject.getFlattenStack(); + // push unique terminator onto stack + this->flattenStack->fastPush(OREF_NULL); - /* First, put a header into the buffer. This is necessary because without */ - /* it, the envelope object would be at 0 offset into the buffer, which is not */ - /* distinguishable from OREF_NULL when the objects are unpacked from buffer. */ - this->copyBuffer(new_instance()); /* and copy into the buffer */ - if (this->destination != OREF_NULL) /* "mailing" an object? */ - firstObject = this; /* include the envelope */ - else - firstObject = this->receiver; /* start with the receiver */ - /* copy the first object */ - this->currentOffset = (LONG)this->copyBuffer(firstObject); - /* point to the copied one */ - newSelf = (RexxObject *)(this->bufferStart() + this->currentOffset); + // First, put a header into the buffer. This is necessary because without + // it, the envelope object would be at 0 offset into the buffer, which is not + // distinguishable from OREF_NULL when the objects are unpacked from buffer. - /* primitive behaviour? */ - if (ObjectHasNonPrimitiveBehaviour(newSelf)) { - /* no, we can do regular mr call */ - behaviourTypeNum = (short)(((RexxBehaviour *)((((ULONG)(newSelf->behaviour)) & ~BEHAVIOUR_NON_PRIMITIVE) + this->bufferStart()))->typenum()); - } else { - /* primitive, typenum is in */ - /* behaviour field */ - behaviourTypeNum = (short)((ULONG)(newSelf->behaviour)); - } - newSelf->flatten(this); /* start the flatten process. */ - for (flattenObj = this->flattenStack->fastPop(); - flattenObj != OREF_NULL; - flattenObj = this->flattenStack->fastPop()) { + // the header is just a dummy minimal object instance. We don't bother adding + // this to the dup table, as it won't ever be duped. + this->copyBuffer(new_instance()); + // we start the flattening process with the received object + firstObject = this->receiver; - /* save the working offset */ - this->currentOffset = (LONG)flattenObj; - /* compute actual addr of obj */ - flattenObj = (RexxObject *)((ULONG)flattenObj + this->bufferStart()); - /* primitive behaviour? */ - if (ObjectHasNonPrimitiveBehaviour(flattenObj)) { - /* no, we can do regular mr call */ - behaviourTypeNum = (short)(((RexxBehaviour *)(((ULONG)(flattenObj->behaviour) & ~BEHAVIOUR_NON_PRIMITIVE) + this->bufferStart()))->typenum()); - } else { - /* primitive, typenum is in */ - /* behaviour field */ - behaviourTypeNum = (short)((ULONG)(flattenObj->behaviour)); - } - flattenObj->flatten(this); /* let this obj flatten its refs */ - } - memoryObject.returnFlattenStack(); /* done with the flatten stack */ - return this; -} + this->currentOffset = this->copyBuffer(firstObject); + // make sure we add this to the dup table in case it's self-referential at any point + associateObject(firstObject, this->currentOffset); + /* point to the copied one */ + newSelf = (RexxObject *)(this->bufferStart() + this->currentOffset); -RexxObject *RexxEnvelope::unpack() -/******************************************************************************/ -/* Function: Unpack an envelope */ -/******************************************************************************/ -{ - long objsize; - FILE *objfile; - char *op; + // ok, keep flattening until will find our marker object on the stack + newSelf->flatten(this); /* start the flatten process. */ - /* ******************************************************************************/ - /* *** Temporary - Just read object from a file for now. */ - /* ******************************************************************************/ - printf("Reading object from the file flatten.obj.\n"); - - objfile = fopen("flatten.obj","rb"); /* open for binary read */ - fseek(objfile,0,SEEK_SET); /* Start at beginning of file. */ - /* Read the buffer size buffer */ - fread(&objsize, 1, sizeof(objsize), objfile); - /* Create new buffer of objSize */ - OrefSet(this, this->buffer, (RexxSmartBuffer *)new_buffer(objsize)); - /* Starting point of buffer, relative*/ - /* to the end of the buffer */ - op = ((PCHAR)(this->buffer) + ObjectSize(this->buffer)) - objsize; - fread(op,1,objsize,objfile); /* Now read in entire flattened obj */ - fclose(objfile); /* close the file */ - - /* puff up flattened buffer/objects */ - this->puff((RexxBuffer *)this->buffer, op); - OrefSet(this,this->buffer,OREF_NULL);/* allow the crippled buffer to be */ - /* garbage collected--not safe to use*/ - - /* And finally, tell the envelope to send the saved message to the receiver. */ - /* NOTE: this->receiver is actaully the original envelope, so we tell the */ - /* original envelope to send message to real receiver.... */ - - return this->execute(); + for (flattenObj = this->flattenStack->fastPop(); + flattenObj != OREF_NULL; + flattenObj = this->flattenStack->fastPop()) + { + // the popped object is actuall an object offset. We need to convert this into a + // real object pointer + this->currentOffset = (size_t)flattenObj; + flattenObj = (RexxObject *)(this->bufferStart() + this->currentOffset); + // and flatten the next object + flattenObj->flatten(this); /* let this obj flatten its refs */ + } + memoryObject.returnFlattenStack(); /* done with the flatten stack */ + return this; } void RexxEnvelope::puff( RexxBuffer *buffer, /* buffer object to unflatten */ - PCHAR startPointer) /* start of buffered data */ + char *startPointer) /* start of buffered data */ /******************************************************************************/ /* Function: Puff into an envelope and remove its contents (unflatten the */ /* stuff ) */ /******************************************************************************/ { + int primitiveTypeNum; /* primitive behaviour type number */ - char *endPointer; /* end of the buffer */ - char *bufferPointer; /* current pointer within the buffer */ - RexxBehaviour *objBehav; /* behaviour of current object */ - long primitiveTypeNum; /* primitive behaviour type number */ + char *bufferPointer = startPointer; /* copy the starting point */ + /* point to end of buffer */ + char *endPointer = (char *)buffer + ObjectSize(buffer); - bufferPointer = startPointer; /* copy the starting point */ - /* point to end of buffer */ - endPointer = (PCHAR)buffer + ObjectSize(buffer); + /* Set objoffset to the real address of the new objects. This tells */ + /* mark_general to fix the object's refs and set their live flags. */ + memoryObject.setObjectOffset((size_t)bufferPointer); + /* Now traverse the buffer fixing all of the behaviour pointers of the objects. */ + while (bufferPointer < endPointer) + { + RexxObject *puffObject = (RexxObject *)bufferPointer; - /* Set objoffset to the real address of the new objects. This tells */ - /* mark_general to fix the object's refs and set their live flags. */ - memoryObject.setObjectOffset((long)bufferPointer); - /* Now traverse the buffer fixing all of the behaviour pointers of the objects. */ - while (bufferPointer < endPointer) { - /* a non-primitive behaviour */ - /* These are actually in flattened */ - /* storgage. */ - if (ObjectHasNonPrimitiveBehaviour(bufferPointer)) { - /* Yes, lets get the behaviour Object*/ - objBehav = (RexxBehaviour *)(((long)(((RexxObject *)bufferPointer)->behaviour) & ~BEHAVIOUR_NON_PRIMITIVE) + ((RexxBuffer *)buffer)->address()); - /* Resolve the static behaviour info */ - resolveNonPrimitiveBehaviour(((RexxBehaviour *)objBehav)); - /* Set this objects behaviour. */ - ((RexxObject *)bufferPointer)->behaviour = (RexxBehaviour *)objBehav; - /* get the behaviour's type number */ - primitiveTypeNum = (long)objBehav->typenum(); + /* a non-primitive behaviour */ + /* These are actually in flattened */ + /* storgage. */ + if (ObjectHasNonPrimitiveBehaviour(puffObject)) + { - } - else { - /* originally a primitive; the */ - /* type number is the behaviour */ - primitiveTypeNum = (long)((RexxObject *)bufferPointer)->behaviour; - /* was a primitive, stays a primitive*/ - ((RexxObject *)bufferPointer)->behaviour = (RexxBehaviour *)(&pbehav[primitiveTypeNum]); - } - /* Force fix-up of */ - /*VirtualFunctionTable, */ + /* Yes, lets get the behaviour Object*/ + RexxBehaviour *objBehav = (RexxBehaviour *)(((long)(puffObject->behaviour) & ~BEHAVIOUR_NON_PRIMITIVE) + ((RexxBuffer *)buffer)->address()); + /* Resolve the static behaviour info */ + resolveNonPrimitiveBehaviour(objBehav); + /* Set this objects behaviour. */ + puffObject->behaviour = objBehav; + /* get the behaviour's type number */ + primitiveTypeNum = objBehav->typenum(); + + } + else + { + /* originally a primitive; the */ + /* type number is the behaviour */ + primitiveTypeNum = (int)(puffObject->behaviour); + /* was a primitive, stays a primitive*/ + puffObject->behaviour = &pbehav[primitiveTypeNum]; + } + /* Force fix-up of */ + /*VirtualFunctionTable, */ #ifdef AIX /* The very first thing of an Object is its VFT. It seems, that if this VFT */ /* of an Object is used several times, the AIX-optimizer stores it in a */ @@ -400,144 +335,117 @@ /* cuted in a separate module the optimizer is not able to do so, */ /* overrides the pointer to the VFT in the tokenized script and uses the */ /* correct on. This behaviour is only seen in AIX */ - ic_setVirtualFunctions(bufferPointer, primitiveTypeNum); + ic_setVirtualFunctions(bufferPointer, primitiveTypeNum); #else - setVirtualFunctions(bufferPointer, primitiveTypeNum); + setVirtualFunctions(bufferPointer, primitiveTypeNum); #endif - SetObjectLive(bufferPointer); /* Then Mark this object as live. */ - /* Mark other referenced objs */ - /* Note that this flavor of */ - /* mark_general should update the */ - /* mark fields in the objects. */ - ((RexxObject *)bufferPointer)->liveGeneral(); - /* Point to next object in image. */ - bufferPointer += ObjectSize(bufferPointer); - } - memoryObject.setObjectOffset(0); /* all done with the fixups! */ + SetObjectLive(puffObject); /* Then Mark this object as live. */ + /* Mark other referenced objs */ + /* Note that this flavor of */ + /* mark_general should update the */ + /* mark fields in the objects. */ + puffObject->liveGeneral(); + /* Point to next object in image. */ + bufferPointer += ObjectSize(puffObject); + } + memoryObject.setObjectOffset(0); /* all done with the fixups! */ - /* Prepare to reveal the objects in */ - /*the buffer. */ - /* our receiver object is the inital */ - /* envelope. This also keeps a */ - /* reference to original envelope so */ - /* we don't loose it. */ - OrefSet(this,this->receiver,(OREF)(startPointer + ObjectSize(startPointer))); - /* chop off end of buffer to reveal */ - /* its contents to memory obj */ -// SetObjectSize(buffer, startPointer - (ULONG)buffer); + /* Prepare to reveal the objects in */ + /*the buffer. */ + /* our receiver object is the inital */ + /* envelope. This also keeps a */ + /* reference to original envelope so */ + /* we don't loose it. */ + OrefSet(this,this->receiver,(RexxObject *)(startPointer + ObjectSize(startPointer))); + /* chop off end of buffer to reveal */ + /* its contents to memory obj */ - SetObjectSize(buffer, (unsigned long)startPointer - (unsigned long)buffer + ObjectSize(startPointer)); - /* HOL: otherwise an object with 20 bytes will be left */ + SetObjectSize(buffer, (char *)startPointer - (char *)buffer + ObjectSize(startPointer)); + /* HOL: otherwise an object with 20 bytes will be left */ - /* Now we have real objects in real memory. Time to send unflatten to activate */ - /* any proxies, */ - /* the dup table is used by */ - /*proxies to if they have already */ - /*been run, is so they can just */ - /*get their newthis from the table */ - /*rather than running again. */ - OrefSet(this, this->duptable, new_object_table()); - OrefSet(this, this->savetable, new_object_table()); - /* move past header to envelope */ - bufferPointer = startPointer + ObjectSize(startPointer); - /* Set envelope to the real address of the new objects. This tells */ - /* mark_general to send unflatten to run any proxies. */ - memoryObject.setEnvelope(this); /* tell memory to send unflatten */ + /* move past header to envelope */ + bufferPointer = startPointer + ObjectSize(startPointer); + /* Set envelope to the real address of the new objects. This tells */ + /* mark_general to send unflatten to run any proxies. */ + memoryObject.setEnvelope(this); /* tell memory to send unflatten */ - /* Now traverse the buffer running any proxies. */ - while (bufferPointer < endPointer) { - /* Since a GC could happen at anytime*/ - /* we need to check to make sure the*/ - /* we are going now unflatten is */ - /* still alive, since all who */ - /* reference it may have already */ - /* run and gotten the info from it */ - /* and no longer reference it. */ - if (ObjectIsLive(bufferPointer)) - /* Mark other referenced objs */ - ((RexxObject *)bufferPointer)->liveGeneral(); - /* Note that this flavor of */ - /* mark_general will run any proxies */ - /* created by unflatten and fixup */ - /* the refs to them. */ - /* Point to next object in image. */ - bufferPointer += ObjectSize(bufferPointer); - } + /* Now traverse the buffer running any proxies. */ + while (bufferPointer < endPointer) + { + /* Since a GC could happen at anytime*/ + /* we need to check to make sure the*/ + /* we are going now unflatten is */ + /* still alive, since all who */ + /* reference it may have already */ + /* run and gotten the info from it */ + /* and no longer reference it. */ + if (ObjectIsLive(bufferPointer)) + /* Mark other referenced objs */ + ((RexxObject *)bufferPointer)->liveGeneral(); + /* Note that this flavor of */ + /* mark_general will run any proxies */ + /* created by unflatten and fixup */ + /* the refs to them. */ + /* Point to next object in image. */ + bufferPointer += ObjectSize(bufferPointer); + } - /* Tell memory we're done */ - memoryObject.setEnvelope(OREF_NULL); /* unflattening. */ + /* Tell memory we're done */ + memoryObject.setEnvelope(OREF_NULL); /* unflattening. */ - /* Before we run the method we need */ - /* to give the tables a chance to */ - this->rehash(); /* rehash... */ + /* Before we run the method we need */ + /* to give the tables a chance to */ + this->rehash(); /* rehash... */ } -RexxObject *RexxEnvelope::queryObj( +size_t RexxEnvelope::queryObj( RexxObject *obj) /* object to check */ /******************************************************************************/ /* Function: Check to see if we've already flattened an object */ /******************************************************************************/ { - return this->duptable->get(obj); + return (size_t)this->duptable->get(obj); } -RexxObject *RexxEnvelope::queryProxy( - RexxObject *obj) /* target object needing a proxy */ -/******************************************************************************/ -/* Function: See if we already have a proxy for an object in out proxy table */ -/******************************************************************************/ -{ - return this->duptable->get(obj); /* retrieve proxies new address.. */ -} - -RexxObject *RexxEnvelope::copyBuffer( +size_t RexxEnvelope::copyBuffer( RexxObject *obj) /* object to copy */ /******************************************************************************/ /* Function: Copy an object into our flatten buffer */ /******************************************************************************/ { - LONG objOffset; /* offset of the buffered object */ - RexxObject * newObj; /* new buffered object */ - /* Copy the object into the buffer */ - objOffset = this->buffer->copyData((PVOID)obj, ObjectSize(obj)); - /* Add object and its new address */ - /* to the dublicate table */ - newObj = (RexxObject *) (this->buffer->getBuffer()->address() + objOffset); - this->duptable->addOffset((RexxObject *)objOffset, obj); - /* Is this a non primitive Behav */ - if (newObj->behaviour->isNonPrimitiveBehaviour()) { - /* Yes, we will actually flatten it. */ - this->flattenReference(&newObj, objOffset, (RexxObject **)&newObj->behaviour); - newObj->behaviour = (RexxBehaviour *)((long)(newObj->behaviour) | BEHAVIOUR_NON_PRIMITIVE); - } - else { - /* we now wipe out the behaviour and */ - /* set it to its typenum, we use */ - /* destination behaviours */ - newObj->behaviour = (RexxBehaviour *)newObj->behaviour->typenum(); - } - - /* Make sure we clear out the */ - SetNewSpace(newObj); /* OldSpace bit */ - return (RexxObject *)objOffset; /* and return the new offset */ + // copy the object into the buffer, which might cause the buffer to + // resize itself. + size_t objOffset = this->buffer->copyData((void *)obj, ObjectSize(obj)); + // get a reference to the copied object + RexxObject *newObj = (RexxObject *) (this->buffer->getBuffer()->address() + objOffset); + // if this is a non-primative behaviour, we need to flatten it as well. The + // offset is tagged as being a non-primitive behaviour that needs later inflating. + if (newObj->behaviour->isNonPrimitiveBehaviour()) + { + this->flattenReference(&newObj, objOffset, (RexxObject **)&newObj->behaviour); + newObj->behaviour = (RexxBehaviour *)((size_t)(newObj->behaviour) | BEHAVIOUR_NON_PRIMITIVE); + } + else + { + // just replace the behaviour with its type number. This will be used + // to restore it later. + newObj->behaviour = (RexxBehaviour *)newObj->behaviour->typenum(); + } + // if we flattened an object from oldspace, we just copied everything. Make sure + // this is no longer marked as oldspace + SetNewSpace(newObj); + // the offset is what we need + return objOffset; } -RexxObject *RexxEnvelope::execute() -/******************************************************************************/ -/* Function: Execute an unflattened "startat" message */ -/******************************************************************************/ -{ - /* just issue the sendmessage */ - return this->receiver->sendMessage(this->message,this->arguments); -} void RexxEnvelope::rehash() /******************************************************************************/ /* Function: Rehash flattened tables */ /******************************************************************************/ { - long i; /* loop index */ + HashLink i; /* loop index */ RexxTable * index; /* table to flatten */ if (this->rehashtable != OREF_NULL) {/* tables to rehash here? */ @@ -550,39 +458,24 @@ } } -ULONG RexxEnvelope::queryType() +char *RexxEnvelope::bufferStart() /******************************************************************************/ -/* Function: this method returns the type of envelope we are creating */ -/* this is to be used during the flattening process by other objects */ -/* Once we have real location objects, we will query the location object */ -/* to get this info, for now we assume is for mobile unless the location */ -/* string is exactly "EA" */ -/******************************************************************************/ -{ - if (this->destination == OREF_NULL) {/* no location given? */ - return METHOD_ENVELOPE; /* Yes, flattening a program */ - } - e... [truncated message content] |
From: <bi...@us...> - 2007-10-28 00:27:05
|
Revision: 1113 http://oorexx.svn.sourceforge.net/oorexx/?rev=1113&view=rev Author: bigrixx Date: 2007-10-27 17:27:09 -0700 (Sat, 27 Oct 2007) Log Message: ----------- More warning removal Modified Paths: -------------- sandbox/rick/warnings2/kernel/classes/NumberStringClass.cpp sandbox/rick/warnings2/kernel/runtime/GlobalData.cpp sandbox/rick/warnings2/kernel/runtime/RexxEnvelope.cpp sandbox/rick/warnings2/kernel/runtime/RexxHashTable.cpp sandbox/rick/warnings2/kernel/runtime/RexxHashTable.hpp Modified: sandbox/rick/warnings2/kernel/classes/NumberStringClass.cpp =================================================================== --- sandbox/rick/warnings2/kernel/classes/NumberStringClass.cpp 2007-10-27 21:43:32 UTC (rev 1112) +++ sandbox/rick/warnings2/kernel/classes/NumberStringClass.cpp 2007-10-28 00:27:09 UTC (rev 1113) @@ -617,7 +617,7 @@ } /* is long value expressable as a */ /* whole number in REXX term. */ - if (createdDigits <= 9 && intnum >= Numerics::validMaxWhole[NumDigits -1]) { + if (createdDigits <= 9 && intnum >= Numerics::validMaxWhole[createdDigits - 1]) { return NO_LONG; /* nope, not a valid long. */ } Modified: sandbox/rick/warnings2/kernel/runtime/GlobalData.cpp =================================================================== --- sandbox/rick/warnings2/kernel/runtime/GlobalData.cpp 2007-10-27 21:43:32 UTC (rev 1112) +++ sandbox/rick/warnings2/kernel/runtime/GlobalData.cpp 2007-10-28 00:27:09 UTC (rev 1113) @@ -288,7 +288,7 @@ internalMethodEntry internalMethodTable[] = { #include "NativeMethods.h" /* bring in the internal method table*/ - NULL, NULL /* final empty entry */ + {NULL, NULL} /* final empty entry */ }; } Modified: sandbox/rick/warnings2/kernel/runtime/RexxEnvelope.cpp =================================================================== --- sandbox/rick/warnings2/kernel/runtime/RexxEnvelope.cpp 2007-10-27 21:43:32 UTC (rev 1112) +++ sandbox/rick/warnings2/kernel/runtime/RexxEnvelope.cpp 2007-10-28 00:27:09 UTC (rev 1113) @@ -215,7 +215,7 @@ RexxEnvelope *RexxEnvelope::pack( - RexxObject *receiver) /* the receiver object */ + RexxObject *_receiver) /* the receiver object */ /******************************************************************************/ /* Function: Pack an envelope item */ /******************************************************************************/ @@ -224,7 +224,7 @@ RexxObject *newSelf; /* the flattened envelope */ RexxObject *firstObject; /* first object to flatten */ - OrefSet(this, this->receiver, receiver); + OrefSet(this, this->receiver, _receiver); // create a save table to protect any objects (such as proxy // objects) we create during flattening. OrefSet(this, this->savetable, new_object_table()); @@ -275,7 +275,7 @@ } void RexxEnvelope::puff( - RexxBuffer *buffer, /* buffer object to unflatten */ + RexxBuffer *sourceBuffer, /* buffer object to unflatten */ char *startPointer) /* start of buffered data */ /******************************************************************************/ /* Function: Puff into an envelope and remove its contents (unflatten the */ @@ -286,7 +286,7 @@ char *bufferPointer = startPointer; /* copy the starting point */ /* point to end of buffer */ - char *endPointer = (char *)buffer + ObjectSize(buffer); + char *endPointer = (char *)sourceBuffer + ObjectSize(sourceBuffer); /* Set objoffset to the real address of the new objects. This tells */ /* mark_general to fix the object's refs and set their live flags. */ @@ -303,7 +303,7 @@ { /* Yes, lets get the behaviour Object*/ - RexxBehaviour *objBehav = (RexxBehaviour *)(((long)(puffObject->behaviour) & ~BEHAVIOUR_NON_PRIMITIVE) + ((RexxBuffer *)buffer)->address()); + RexxBehaviour *objBehav = (RexxBehaviour *)(((long)(puffObject->behaviour) & ~BEHAVIOUR_NON_PRIMITIVE) + sourceBuffer->address()); /* Resolve the static behaviour info */ resolveNonPrimitiveBehaviour(objBehav); /* Set this objects behaviour. */ @@ -360,7 +360,7 @@ /* chop off end of buffer to reveal */ /* its contents to memory obj */ - SetObjectSize(buffer, (char *)startPointer - (char *)buffer + ObjectSize(startPointer)); + SetObjectSize(sourceBuffer, (char *)startPointer - (char *)sourceBuffer + ObjectSize(startPointer)); /* HOL: otherwise an object with 20 bytes will be left */ @@ -423,7 +423,9 @@ // offset is tagged as being a non-primitive behaviour that needs later inflating. if (newObj->behaviour->isNonPrimitiveBehaviour()) { - this->flattenReference(&newObj, objOffset, (RexxObject **)&newObj->behaviour); + void *behavPtr = &newObj->behaviour; + + this->flattenReference(&newObj, objOffset, (RexxObject **)behavPtr); newObj->behaviour = (RexxBehaviour *)((size_t)(newObj->behaviour) | BEHAVIOUR_NON_PRIMITIVE); } else Modified: sandbox/rick/warnings2/kernel/runtime/RexxHashTable.cpp =================================================================== --- sandbox/rick/warnings2/kernel/runtime/RexxHashTable.cpp 2007-10-27 21:43:32 UTC (rev 1112) +++ sandbox/rick/warnings2/kernel/runtime/RexxHashTable.cpp 2007-10-28 00:27:09 UTC (rev 1113) @@ -112,7 +112,7 @@ /******************************************************************************/ { RexxHashTable *newHash; /* new hash table object */ - RexxTable *newTable; /* associated table object */ + RexxTable *newObj; /* associated table object */ size_t bytes; /* size of the allocated object */ size_t bucketSize; /* size of the bucket */ @@ -127,18 +127,18 @@ /* make sure we've got proper sizes for each of the object parts. */ companionSize = roundObjectBoundary(companionSize); /* Get space for two objects */ - newTable = (RexxTable *)new_object(bytes + companionSize); - ClearObject(newTable); /* clear the entire lot */ + newObj = (RexxTable *)new_object(bytes + companionSize); + ClearObject(newObj); /* clear the entire lot */ /* address the hash table */ - newHash = (RexxHashTable *)(((PCHAR)newTable) + companionSize); + newHash = (RexxHashTable *)(((PCHAR)newObj) + companionSize); /* compute total size of the hash */ /* table (allowing for possible */ /* over allocation by the memory */ /* manager */ - bytes = ObjectSize(newTable) - companionSize; + bytes = ObjectSize(newObj) - companionSize; SetUpNewObject((RexxObject *)newHash, bytes); /* make this an object */ /* reduce the companion size */ - SetObjectSize(newTable, companionSize); + SetObjectSize(newObj, companionSize); /* do a dummy new against the hash */ /* table to get the correct virtual */ /* function table set up */ @@ -152,8 +152,8 @@ /* hook the hash into the companion */ /* OrefSet is not used, because the */ /* companion object is not fully set */ - newTable->contents = newHash; /* up yet (no behaviour) */ - return newTable; /* return the object */ + newObj->contents = newHash; /* up yet (no behaviour) */ + return newObj; /* return the object */ } void RexxHashTable::live(void) @@ -217,8 +217,8 @@ } RexxHashTable * RexxHashTable::add( - RexxObject *value, /* added element value */ - RexxObject *index) /* added index value */ + RexxObject *_value, /* added element value */ + RexxObject *_index) /* added index value */ /******************************************************************************/ /* Function: Add an element to a hash table. If the table needs to expand, */ /* the new table is returned. */ @@ -226,21 +226,21 @@ { HashLink position; /* current position */ - position = hashIndex(index); /* calculate the hash slot */ + position = hashIndex(_index); /* calculate the hash slot */ /* if the hash slot is empty */ if (this->entries[position].index == OREF_NULL) { /* fill in both the value and index */ - OrefSet(this,this->entries[position].value,value); - OrefSet(this,this->entries[position].index,index); + OrefSet(this,this->entries[position].value, _value); + OrefSet(this,this->entries[position].index, _index); return OREF_NULL; /* successful addition */ } /* go insert */ - return this->insert(value, index, position, FULL_TABLE); + return this->insert(_value, _index, position, FULL_TABLE); } RexxHashTable * RexxHashTable::primitiveAdd( - RexxObject *value, /* added element value */ - RexxObject *index) /* added index value */ + RexxObject *_value, /* added element value */ + RexxObject *_index) /* added index value */ /******************************************************************************/ /* Function: Add an element to a hash table. If the table needs to expand, */ /* the new table is returned. */ @@ -248,42 +248,42 @@ { HashLink position; /* current position */ - position = hashPrimitiveIndex(index); /* calculate the hash slot */ + position = hashPrimitiveIndex(_index); /* calculate the hash slot */ /* if the hash slot is empty */ if (this->entries[position].index == OREF_NULL) { /* fill in both the value and index */ - OrefSet(this,this->entries[position].value,value); - OrefSet(this,this->entries[position].index,index); + OrefSet(this,this->entries[position].value, _value); + OrefSet(this,this->entries[position].index, _index); return OREF_NULL; /* successful addition */ } /* go insert */ - return this->insert(value, index, position, PRIMITIVE_TABLE); + return this->insert(_value, _index, position, PRIMITIVE_TABLE); } RexxObject *RexxHashTable::remove( - RexxObject *index) /* index to remove */ + RexxObject *_index) /* index to remove */ /******************************************************************************/ /* Function: Remove an element from a hash table */ /******************************************************************************/ { HashLink position; /* target hash position */ HashLink previous; /* previous hash position */ - HashLink next; /* next hash position */ + HashLink _next; /* next hash position */ RexxObject *removed; /* removed item value */ - position = hashIndex(index); /* calculate the hash slot */ + position = hashIndex(_index); /* calculate the hash slot */ previous = NO_LINK; /* no previous slot yet */ /* have an entry at this slot */ if (this->entries[position].index != OREF_NULL) { do { /* while more items in chain */ /* get a match? */ - if (EQUAL_VALUE(index, this->entries[position].index)) { + if (EQUAL_VALUE(_index, this->entries[position].index)) { /* save the current value */ removed = this->entries[position].value; /* get the next pointer */ - next = this->entries[position].next; - if (next == NO_MORE) { /* end of the chain? */ + _next = this->entries[position].next; + if (_next == NO_MORE) { /* end of the chain? */ /* clear this slot entry */ OrefSet(this,this->entries[position].index,OREF_NULL); OrefSet(this,this->entries[position].value,OREF_NULL); @@ -300,17 +300,17 @@ } /* non-terminal chain element */ else { /* close up the link */ - this->entries[position].next = this->entries[next].next; + this->entries[position].next = this->entries[_next].next; /* copy value and index to current */ - OrefSet(this,this->entries[position].index,this->entries[next].index); - OrefSet(this,this->entries[position].value,this->entries[next].value); + OrefSet(this,this->entries[position].index,this->entries[_next].index); + OrefSet(this,this->entries[position].value,this->entries[_next].value); /* clear the next entry */ - OrefSet(this,this->entries[next].index,OREF_NULL); - OrefSet(this,this->entries[next].value,OREF_NULL); + OrefSet(this,this->entries[_next].index,OREF_NULL); + OrefSet(this,this->entries[_next].value,OREF_NULL); /* set to "pristine" condition */ - this->entries[next].next = NO_MORE; - if (this->free < next) /* new-low water mark? */ - this->free = next; /* reset to this point */ + this->entries[_next].next = NO_MORE; + if (this->free < _next) /* new-low water mark? */ + this->free = _next; /* reset to this point */ } return removed; /* return removed element value */ } @@ -323,29 +323,29 @@ } RexxObject *RexxHashTable::primitiveRemove( - RexxObject *index) /* index to remove */ + RexxObject *_index) /* index to remove */ /******************************************************************************/ /* Function: Remove an element from a hash table */ /******************************************************************************/ { HashLink position; /* target hash position */ HashLink previous; /* previous hash position */ - HashLink next; /* next hash position */ + HashLink _next; /* next hash position */ RexxObject *removed; /* removed item value */ - position = hashPrimitiveIndex(index); /* calculate the hash slot */ + position = hashPrimitiveIndex(_index); /* calculate the hash slot */ previous = NO_LINK; /* no previous slot yet */ /* have an entry at this slot */ if (this->entries[position].index != OREF_NULL) { do { /* while more items in chain */ /* get a match? */ - if (index == this->entries[position].index) { + if (_index == this->entries[position].index) { /* save the current value */ removed = this->entries[position].value; /* get the next pointer */ - next = this->entries[position].next; - if (next == NO_MORE) { /* end of the chain? */ + _next = this->entries[position].next; + if (_next == NO_MORE) { /* end of the chain? */ /* clear this slot entry */ OrefSet(this,this->entries[position].index,OREF_NULL); OrefSet(this,this->entries[position].value,OREF_NULL); @@ -362,17 +362,17 @@ } /* non-terminal chain element */ else { /* close up the link */ - this->entries[position].next = this->entries[next].next; + this->entries[position].next = this->entries[_next].next; /* copy value and index to current */ - OrefSet(this,this->entries[position].index,this->entries[next].index); - OrefSet(this,this->entries[position].value,this->entries[next].value); + OrefSet(this,this->entries[position].index,this->entries[_next].index); + OrefSet(this,this->entries[position].value,this->entries[_next].value); /* clear the next entry */ - OrefSet(this,this->entries[next].index,OREF_NULL); - OrefSet(this,this->entries[next].value,OREF_NULL); + OrefSet(this,this->entries[_next].index,OREF_NULL); + OrefSet(this,this->entries[_next].value,OREF_NULL); /* set to "pristine" condition */ - this->entries[next].next = NO_MORE; - if (this->free < next) /* new-low water mark? */ - this->free = next; /* reset to this point */ + this->entries[_next].next = NO_MORE; + if (this->free < _next) /* new-low water mark? */ + this->free = _next; /* reset to this point */ } return removed; /* return removed element value */ } @@ -385,8 +385,8 @@ } RexxObject *RexxHashTable::removeItem( - RexxObject *value, /* item to remove */ - RexxObject *index ) /* index to remove */ + RexxObject *_value, /* item to remove */ + RexxObject *_index ) /* index to remove */ /******************************************************************************/ /* Function: Remove the tuple (value, item) from the hash table. If */ /* the item is not found, .nil is returned. */ @@ -394,22 +394,22 @@ { HashLink position; /* target hash position */ HashLink previous; /* previous hash position */ - HashLink next; /* next hash position */ + HashLink _next; /* next hash position */ RexxObject * removed; /* removed item value */ - position = hashIndex(index); /* calculate the hash slot */ + position = hashIndex(_index); /* calculate the hash slot */ previous = NO_LINK; /* no previous slot yet */ /* have an entry at this slot */ if (this->entries[position].index != OREF_NULL) { do { /* while more items in chain */ /* get a match? */ - if (EQUAL_VALUE(index, this->entries[position].index) && - EQUAL_VALUE(value, this->entries[position].value)) { + if (EQUAL_VALUE(_index, this->entries[position].index) && + EQUAL_VALUE(_value, this->entries[position].value)) { /* save the current value */ removed = this->entries[position].value; /* get the next pointer */ - next = this->entries[position].next; - if (next == NO_MORE) { /* end of the chain? */ + _next = this->entries[position].next; + if (_next == NO_MORE) { /* end of the chain? */ /* clear this slot entry */ OrefSet(this,this->entries[position].index,OREF_NULL); OrefSet(this,this->entries[position].value,OREF_NULL); @@ -419,17 +419,17 @@ } /* non-terminal chain element */ else { /* close up the link */ - this->entries[position].next = this->entries[next].next; + this->entries[position].next = this->entries[_next].next; /* copy value and index to current */ - OrefSet(this,this->entries[position].index,this->entries[next].index); - OrefSet(this,this->entries[position].value,this->entries[next].value); + OrefSet(this,this->entries[position].index,this->entries[_next].index); + OrefSet(this,this->entries[position].value,this->entries[_next].value); /* clear the next entry */ - OrefSet(this,this->entries[next].index,OREF_NULL); - OrefSet(this,this->entries[next].value,OREF_NULL); + OrefSet(this,this->entries[_next].index,OREF_NULL); + OrefSet(this,this->entries[_next].value,OREF_NULL); /* set to "pristine" condition */ - this->entries[next].next = NO_MORE; - if (this->free < next) /* new-low water mark? */ - this->free = next; /* reset to this point */ + this->entries[_next].next = NO_MORE; + if (this->free < _next) /* new-low water mark? */ + this->free = _next; /* reset to this point */ } return removed; /* return removed element value */ } @@ -443,8 +443,8 @@ RexxObject *RexxHashTable::primitiveRemoveItem( - RexxObject *value, /* item to remove */ - RexxObject *index ) /* index to remove */ + RexxObject *_value, /* item to remove */ + RexxObject *_index ) /* index to remove */ /******************************************************************************/ /* Function: Remove the tuple (value, item) from the hash table. If */ /* the item is not found, .nil is returned. */ @@ -452,21 +452,21 @@ { HashLink position; /* target hash position */ HashLink previous; /* previous hash position */ - HashLink next; /* next hash position */ + HashLink _next; /* next hash position */ RexxObject * removed; /* removed item value */ - position = hashPrimitiveIndex(index); /* calculate the hash slot */ + position = hashPrimitiveIndex(_index); /* calculate the hash slot */ previous = NO_LINK; /* no previous slot yet */ /* have an entry at this slot */ if (this->entries[position].index != OREF_NULL) { do { /* while more items in chain */ /* get a match? */ - if (index == this->entries[position].index && value == this->entries[position].value) { + if (_index == this->entries[position].index && _value == this->entries[position].value) { /* save the current value */ removed = this->entries[position].value; /* get the next pointer */ - next = this->entries[position].next; - if (next == NO_MORE) { /* end of the chain? */ + _next = this->entries[position].next; + if (_next == NO_MORE) { /* end of the chain? */ /* clear this slot entry */ OrefSet(this,this->entries[position].index,OREF_NULL); OrefSet(this,this->entries[position].value,OREF_NULL); @@ -476,17 +476,17 @@ } /* non-terminal chain element */ else { /* close up the link */ - this->entries[position].next = this->entries[next].next; + this->entries[position].next = this->entries[_next].next; /* copy value and index to current */ - OrefSet(this,this->entries[position].index,this->entries[next].index); - OrefSet(this,this->entries[position].value,this->entries[next].value); + OrefSet(this,this->entries[position].index,this->entries[_next].index); + OrefSet(this,this->entries[position].value,this->entries[_next].value); /* clear the next entry */ - OrefSet(this,this->entries[next].index,OREF_NULL); - OrefSet(this,this->entries[next].value,OREF_NULL); + OrefSet(this,this->entries[_next].index,OREF_NULL); + OrefSet(this,this->entries[_next].value,OREF_NULL); /* set to "pristine" condition */ - this->entries[next].next = NO_MORE; - if (this->free < next) /* new-low water mark? */ - this->free = next; /* reset to this point */ + this->entries[_next].next = NO_MORE; + if (this->free < _next) /* new-low water mark? */ + this->free = _next; /* reset to this point */ } return removed; /* return removed element value */ } @@ -499,8 +499,8 @@ } RexxObject *RexxHashTable::primitiveHasItem( - RexxObject *value, /* item to locate */ - RexxObject *index ) /* index to locate */ + RexxObject *_value, /* item to locate */ + RexxObject *_index ) /* index to locate */ /******************************************************************************/ /* Function: Determine if a tuple (value, item) pair exists in the hash */ /* table. Return TRUE if found, FALSE other wise. */ @@ -508,12 +508,12 @@ { HashLink position; /* target hash position */ - position = hashPrimitiveIndex(index); /* calculate the hash slot */ + position = hashPrimitiveIndex(_index); /* calculate the hash slot */ /* have an entry at this slot */ if (this->entries[position].index != OREF_NULL) { do { /* while more items in chain */ /* get a match? */ - if (index == this->entries[position].index && value == this->entries[position].value) + if (_index == this->entries[position].index && _value == this->entries[position].value) /* got the one we want */ return (RexxObject *)TheTrueObject; /* step to the next link */ @@ -523,8 +523,8 @@ } RexxObject *RexxHashTable::hasItem( - RexxObject *value, /* item to locate */ - RexxObject *index ) /* index to locate */ + RexxObject *_value, /* item to locate */ + RexxObject *_index ) /* index to locate */ /******************************************************************************/ /* Function: Determine if a tuple (value, item) pair exists in the hash */ /* table. Return TRUE if found, FALSE other wise. */ @@ -532,13 +532,13 @@ { HashLink position; /* target hash position */ - position = hashIndex(index); /* calculate the hash slot */ + position = hashIndex(_index); /* calculate the hash slot */ /* have an entry at this slot */ if (this->entries[position].index != OREF_NULL) { do { /* while more items in chain */ /* get a match? */ - if (EQUAL_VALUE(index, this->entries[position].index) && - EQUAL_VALUE(value, this->entries[position].value)) + if (EQUAL_VALUE(_index, this->entries[position].index) && + EQUAL_VALUE(_value, this->entries[position].value)) /* got the one we want */ return (RexxObject *)TheTrueObject; /* step to the next link */ @@ -555,7 +555,7 @@ * * @return .true if it exists, .false otherwise. */ -RexxObject *RexxHashTable::hasItem(RexxObject *value) +RexxObject *RexxHashTable::hasItem(RexxObject *_value) { // our size size_t size = this->totalSlotsSize(); @@ -568,7 +568,7 @@ // if we have an item, see if it's the one we're looking for. if (ep->index != OREF_NULL) { - if (EQUAL_VALUE(value, ep->value)) + if (EQUAL_VALUE(_value, ep->value)) { return TheTrueObject; // return the index value @@ -586,7 +586,7 @@ * * @return .true if it exists, .false otherwise. */ -RexxObject *RexxHashTable::removeItem(RexxObject *value) +RexxObject *RexxHashTable::removeItem(RexxObject *_value) { // our size size_t size = this->totalSlotsSize(); @@ -599,11 +599,11 @@ // if we have an item, see if it's the one we're looking for. if (ep->index != OREF_NULL) { - if (EQUAL_VALUE(value, ep->value)) + if (EQUAL_VALUE(_value, ep->value)) { // this is complicated, so it's easier to just remove // this using the fully qualified tuple. - return removeItem(value, ep->index); + return removeItem(_value, ep->index); } } } @@ -612,8 +612,8 @@ RexxObject *RexxHashTable::nextItem( - RexxObject *value, /* item to locate */ - RexxObject *index ) /* index to locate */ + RexxObject *_value, /* item to locate */ + RexxObject *_index ) /* index to locate */ /******************************************************************************/ /* Function: Return the next item with the key index that follows the */ /* given (value index) pair. Used only for superscope lookup. */ @@ -624,15 +624,15 @@ HashLink position; /* target hash position */ RexxObject *scope; /* returned scope */ - position = hashIndex(index); /* calculate the hash slot */ + position = hashIndex(_index); /* calculate the hash slot */ /* have an entry at this slot */ if (this->entries[position].index != OREF_NULL) { do { /* while more items in chain */ /* get a match? */ - if (this->entries[position].index == index && this->entries[position].value == value) { + if (this->entries[position].index == _index && this->entries[position].value == _value) { while ((position = this->entries[position].next) != NO_MORE) { /* same index value? */ - if (this->entries[position].index == index) + if (this->entries[position].index == _index) /* this is the value we want */ return this->entries[position].value; } @@ -641,7 +641,7 @@ /* step to the next link */ } while ((position = this->entries[position].next) != NO_MORE); /* must be added via setmethod, so */ - scope = this->primitiveGet(index); /* return first one for this index */ + scope = this->primitiveGet(_index);/* return first one for this index */ /* truely not there? */ if (scope == (RexxObject *)OREF_NULL) return TheNilObject; /* return a failure */ @@ -652,8 +652,8 @@ RexxObject *RexxHashTable::primitiveNextItem( - RexxObject *value, /* item to locate */ - RexxObject *index ) /* index to locate */ + RexxObject *_value, /* item to locate */ + RexxObject *_index ) /* index to locate */ /******************************************************************************/ /* Function: Return the next item with the key index that follows the */ /* given (value index) pair. Used only for superscope lookup. */ @@ -664,15 +664,15 @@ HashLink position; /* target hash position */ RexxObject *scope; /* returned scope */ - position = hashPrimitiveIndex(index); /* calculate the hash slot */ + position = hashPrimitiveIndex(_index); /* calculate the hash slot */ /* have an entry at this slot */ if (this->entries[position].index != OREF_NULL) { do { /* while more items in chain */ /* get a match? */ - if (this->entries[position].index == index && this->entries[position].value == value) { + if (this->entries[position].index == _index && this->entries[position].value == _value) { while ((position = this->entries[position].next) != NO_MORE) { /* same index value? */ - if (this->entries[position].index == index) + if (this->entries[position].index == _index) /* this is the value we want */ return this->entries[position].value; } @@ -681,7 +681,7 @@ /* step to the next link */ } while ((position = this->entries[position].next) != NO_MORE); /* must be added via setmethod, so */ - scope = this->primitiveGet(index); /* return first one for this index */ + scope = this->primitiveGet(_index); /* return first one for this index */ /* truely not there? */ if (scope == (RexxObject *)OREF_NULL) return TheNilObject; /* return a failure */ @@ -691,7 +691,7 @@ } RexxArray *RexxHashTable::getAll( - RexxObject *index) /* target index */ + RexxObject *_index) /* target index */ /******************************************************************************/ /* Function: Get all elements with a specified index as an array */ /******************************************************************************/ @@ -701,13 +701,13 @@ RexxArray *result; /* returned result */ size_t i; /* loop counter */ - count = 0L; /* no items found yet */ - position = hashIndex(index); /* calculate the hash slot */ + count = 0; /* no items found yet */ + position = hashIndex(_index); /* calculate the hash slot */ /* have an entry at this slot */ if (this->entries[position].index != OREF_NULL) { do { /* while more items in chain */ /* if got a match */ - if (EQUAL_VALUE(index, this->entries[position].index)) + if (EQUAL_VALUE(_index, this->entries[position].index)) count++; /* bump our counter */ /* step to the next link */ } while ((position = this->entries[position].next) != NO_MORE); @@ -717,11 +717,11 @@ return (RexxArray *)TheNullArray->copy(); result = new_array(count); /* get proper size result array */ - i = 1L; /* start at the first element */ - position = hashIndex(index); /* calculate the hash slot */ + i = 1; /* start at the first element */ + position = hashIndex(_index); /* calculate the hash slot */ do { /* while more items in chain */ /* if got a match */ - if (EQUAL_VALUE(index, this->entries[position].index)) + if (EQUAL_VALUE(_index, this->entries[position].index)) /* copy the value into our array */ result->put(this->entries[position].value,i++); /* step to the next link */ @@ -730,7 +730,7 @@ } RexxArray *RexxHashTable::primitiveGetAll( - RexxObject *index) /* target index */ + RexxObject *_index) /* target index */ /******************************************************************************/ /* Function: Get all elements with a specified index as an array */ /******************************************************************************/ @@ -740,13 +740,13 @@ RexxArray *result; /* returned result */ size_t i; /* loop counter */ - count = 0L; /* no items found yet */ - position = hashPrimitiveIndex(index); /* calculate the hash slot */ + count = 0; /* no items found yet */ + position = hashPrimitiveIndex(_index); /* calculate the hash slot */ /* have an entry at this slot */ if (this->entries[position].index != OREF_NULL) { do { /* while more items in chain */ /* if got a match */ - if (index == this->entries[position].index) + if (_index == this->entries[position].index) count++; /* bump our counter */ /* step to the next link */ } while ((position = this->entries[position].next) != NO_MORE); @@ -757,10 +757,10 @@ result = new_array(count); /* get proper size result array */ i = 1; /* start at the first element */ - position = hashPrimitiveIndex(index); /* calculate the hash slot */ + position = hashPrimitiveIndex(_index); /* calculate the hash slot */ do { /* while more items in chain */ /* if got a match */ - if (index == this->entries[position].index) + if (_index == this->entries[position].index) /* copy the value into our array */ result->put(this->entries[position].value,i++); /* step to the next link */ @@ -769,7 +769,7 @@ } RexxArray *RexxHashTable::stringGetAll( - RexxString *index) /* target index */ + RexxString *_index) /* target index */ /******************************************************************************/ /* Function: Return an array of all value with the same index (using string */ /* lookup semantics) */ @@ -783,17 +783,17 @@ size_t length; /* string length */ RexxString *entry; /* current compare entry */ - data = index->getStringData(); /* get the string data */ - length = index->getLength(); /* and the length also */ - count = 0L; /* no items found yet */ - position = hashStringIndex(index); /* calculate the hash slot */ + data = _index->getStringData(); /* get the string data */ + length = _index->getLength(); /* and the length also */ + count = 0; /* no items found yet */ + position = hashStringIndex(_index); /* calculate the hash slot */ /* have an entry at this slot */ if (this->entries[position].index != OREF_NULL) { do { /* while more items in chain */ /* get the entry */ entry = (RexxString *)this->entries[position].index; /* if got a match */ - if (index == entry || entry->memCompare(data, length)) + if (_index == entry || entry->memCompare(data, length)) count++; /* bump our counter */ /* step to the next link */ } while ((position = this->entries[position].next) != NO_MORE); @@ -803,13 +803,13 @@ return (RexxArray *)TheNullArray->copy(); result = new_array(count); /* get proper size result array */ - i = 1L; /* start at the first element */ - position = hashIndex(index); /* calculate the hash slot */ + i = 1; /* start at the first element */ + position = hashIndex(_index); /* calculate the hash slot */ do { /* while more items in chain */ /* get the entry */ entry = (RexxString *)this->entries[position].index; /* if got a match */ - if (index == entry || entry->memCompare(data, length)) + if (_index == entry || entry->memCompare(data, length)) /* copy the value into our array */ result->put(this->entries[position].value,i++); /* step to the next link */ @@ -818,7 +818,7 @@ } RexxArray *RexxHashTable::allIndex( - RexxObject *value) /* target value item */ + RexxObject *_value) /* target value item */ /******************************************************************************/ /* Function: Return all index items that match the associated value */ /* item. */ @@ -826,16 +826,16 @@ { size_t count; /* count of items to return */ RexxArray * result; /* returned result */ - long i; /* loop counter */ + size_t i; /* loop counter */ size_t j; /* array index */ - count = 0L; /* no items found yet */ + count = 0; /* no items found yet */ /* loop through them all */ - for (i = (long)this->totalSlotsSize() - 1; i >= 0; i--) { + for (i = this->totalSlotsSize(); i > 0; i--) { /* real entry? */ - if (this->entries[i].index != OREF_NULL) { + if (this->entries[i - 1].index != OREF_NULL) { /* is this the item we want? */ - if (EQUAL_VALUE(value, this->entries[i].value)) + if (EQUAL_VALUE(_value, this->entries[i - 1].value)) count++; /* bump our counter */ } } @@ -843,13 +843,13 @@ result = new_array(count); /* get proper size result array */ j = 1; /* start at the first element */ /* loop through them all */ - for (i = (long)this->totalSlotsSize() - 1; i >= 0; i--) { + for (i = this->totalSlotsSize(); i > 0; i--) { /* real entry? */ - if (this->entries[i].index != OREF_NULL) { + if (this->entries[i - 1].index != OREF_NULL) { /* is this the item we want? */ - if (EQUAL_VALUE(value, this->entries[i].value)) + if (EQUAL_VALUE(_value, this->entries[i - 1].value)) /* copy the value into our array */ - result->put(this->entries[i].index, j++); + result->put(this->entries[i - 1].index, j++); } } return result; /* return the result array */ @@ -857,7 +857,7 @@ RexxObject *RexxHashTable::getIndex( - RexxObject *value) /* target object */ + RexxObject *_value) /* target object */ /******************************************************************************/ /* Function: Return an index associated with the supplied item. The result */ /* is undefined for items that are referenced by multiple */ @@ -865,17 +865,17 @@ /******************************************************************************/ { RexxObject *result; /* result index item */ - long i; /* loop counter */ + size_t i; /* loop counter */ result = OREF_NULL; /* no item yet */ /* loop through them all */ - for (i = (long)this->totalSlotsSize() - 1; i >= 0; i--) { + for (i = this->totalSlotsSize(); i > 0; i--) { /* real entry? */ - if (this->entries[i].index != OREF_NULL) { + if (this->entries[i - 1].index != OREF_NULL) { /* is this the item we want? */ - if (EQUAL_VALUE(value, this->entries[i].value)) { + if (EQUAL_VALUE(_value, this->entries[i - 1].value)) { /* get the index */ - result = this->entries[i].index; + result = this->entries[i - 1].index; break; /* finished */ } } @@ -884,19 +884,19 @@ } RexxObject *RexxHashTable::get( - RexxObject *index) /* index of target item */ + RexxObject *_index) /* index of target item */ /******************************************************************************/ /* Function: Get an item from a hash table */ /******************************************************************************/ { HashLink position; /* current position */ - position = hashIndex(index); /* calculate the hash slot */ + position = hashIndex(_index); /* calculate the hash slot */ /* have an entry at this slot */ if (this->entries[position].index != OREF_NULL) { do { /* while more items in chain */ /* if got a match */ - if (EQUAL_VALUE(index, this->entries[position].index)) + if (EQUAL_VALUE(_index, this->entries[position].index)) /* return this item's value */ return this->entries[position].value; /* step to the next link */ @@ -906,19 +906,19 @@ } RexxObject *RexxHashTable::primitiveGet( - RexxObject *index) /* index of target item */ + RexxObject *_index) /* index of target item */ /******************************************************************************/ /* Function: Get an item from a hash table */ /******************************************************************************/ { HashLink position; /* current position */ - position = hashPrimitiveIndex(index); /* calculate the hash slot */ + position = hashPrimitiveIndex(_index); /* calculate the hash slot */ /* have an entry at this slot */ if (this->entries[position].index != OREF_NULL) { do { /* while more items in chain */ /* if got a match */ - if (index == this->entries[position].index) + if (_index == this->entries[position].index) /* return this item's value */ return this->entries[position].value; /* step to the next link */ @@ -928,8 +928,8 @@ } RexxHashTable *RexxHashTable::insert( - RexxObject *value, /* value to insert */ - RexxObject * index, /* index to insert */ + RexxObject *_value, /* value to insert */ + RexxObject * _index, /* index to insert */ HashLink position, /* insertion position */ LONG type ) /* string type insertion */ /******************************************************************************/ @@ -956,11 +956,11 @@ OrefSet(this, entry->index, primeEntry->index); /* set the new values in the first */ /* chain entry */ - OrefSet(this, primeEntry->value, value); - OrefSet(this, primeEntry->index, index); + OrefSet(this, primeEntry->value, _value); + OrefSet(this, primeEntry->index, _index); /* set the overflow location */ - primeEntry->next = (long)over; - this->free = (long)(over-1); /* update free pointer */ + primeEntry->next = over; + this->free = over-1; /* update free pointer */ return OREF_NULL; /* this was a successful addition */ } } @@ -986,49 +986,49 @@ // primitive tables require a primitive index. if (type == PRIMITIVE_TABLE) { - position = newHash->hashPrimitiveIndex(index);/* calculate the hash slot */ + position = newHash->hashPrimitiveIndex(_index);/* calculate the hash slot */ } else { - position = newHash->hashIndex(index);/* calculate the hash slot */ + position = newHash->hashIndex(_index);/* calculate the hash slot */ } /* if the hash slot is empty */ if (newHash->entries[position].index == OREF_NULL) { /* fill in both the value and index */ - OrefSet(newHash, newHash->entries[position].value, value); - OrefSet(newHash, newHash->entries[position].index, index); + OrefSet(newHash, newHash->entries[position].value, _value); + OrefSet(newHash, newHash->entries[position].index, _index); } else /* try to insert again */ - newHash->insert(value, index, position, type); + newHash->insert(_value, _index, position, type); return newHash; /* return the new hash */ } RexxHashTable *RexxHashTable::stringAdd( - RexxObject *value, /* added element value */ - RexxString *index) /* added index value */ + RexxObject *_value, /* added element value */ + RexxString *_index) /* added index value */ /******************************************************************************/ /* Function: Add an element to a hash table, using only string searches */ /******************************************************************************/ { HashLink position; /* current position */ - position = hashStringIndex(index); /* calculate the hash slot */ + position = hashStringIndex(_index); /* calculate the hash slot */ /* if the hash slot is empty */ if (this->entries[position].index == OREF_NULL) { /* fill in both the value and index */ - OrefSet(this,this->entries[position].value,value); - OrefSet(this,this->entries[position].index,index); + OrefSet(this, this->entries[position].value, _value); + OrefSet(this, this->entries[position].index, _index); return OREF_NULL; /* successful addition */ } else /* hash slot is full */ /* go insert */ - return this->insert(value, index, position, STRING_TABLE); + return this->insert(_value, _index, position, STRING_TABLE); } RexxObject *RexxHashTable::stringGet( - RexxString *index) /* index of target item */ + RexxString *_index) /* index of target item */ /******************************************************************************/ /* Function: Search a hash table, restricting the search to string items. */ /******************************************************************************/ @@ -1039,18 +1039,17 @@ RexxString *entry; /* current table entry */ int depth = 0; - data = index->getStringData(); /* get the string data */ - length = index->getLength(); /* and the length also */ + data = _index->getStringData(); /* get the string data */ + length = _index->getLength(); /* and the length also */ - position = hashStringIndex(index); /* calculate the hash slot */ - ULONG indexHash = HASHVALUE(index); /* save the index */ + position = hashStringIndex(_index); /* calculate the hash slot */ /* have an entry at this slot */ if (this->entries[position].index != OREF_NULL) { do { /* while more items in chain */ /* get the entry */ entry = (RexxString *)this->entries[position].index; /* if got a match */ - if (index == entry || (HASHVALUE(entry) == indexHash && entry->memCompare(data, length))) { + if (_index == entry || entry->memCompare(data, length)) { /* return this item's value */ return this->entries[position].value; } @@ -1061,8 +1060,8 @@ } RexxHashTable *RexxHashTable::stringPut( - RexxObject *value, /* value of the item */ - RexxString *index) /* target index */ + RexxObject *_value, /* value of the item */ + RexxString *_index) /* target index */ /******************************************************************************/ /* Function: Add a value to a table, searching only for character string */ /* matches. */ @@ -1074,11 +1073,10 @@ HashLink front; /* starting location */ RexxString *entry; /* current table entry */ - data = index->getStringData(); /* get the string data */ - length = index->getLength(); /* and the length also */ - ULONG indexHash = HASHVALUE(index); /* save the index */ + data = _index->getStringData(); /* get the string data */ + length = _index->getLength(); /* and the length also */ - position = hashStringIndex(index); /* calculate the hash slot */ + position = hashStringIndex(_index); /* calculate the hash slot */ /* have an entry at this slot */ if (this->entries... [truncated message content] |
From: <bi...@us...> - 2007-10-28 11:43:52
|
Revision: 1115 http://oorexx.svn.sourceforge.net/oorexx/?rev=1115&view=rev Author: bigrixx Date: 2007-10-28 04:43:54 -0700 (Sun, 28 Oct 2007) Log Message: ----------- More warning removal Modified Paths: -------------- sandbox/rick/warnings2/kernel/classes/ClassClass.cpp sandbox/rick/warnings2/kernel/classes/ClassClass.hpp sandbox/rick/warnings2/kernel/runtime/RexxNativeMethod.cpp sandbox/rick/warnings2/kernel/runtime/RexxSOMProxy.cpp sandbox/rick/warnings2/kernel/runtime/RexxVariableDictionary.cpp sandbox/rick/warnings2/kernel/runtime/Setup.cpp sandbox/rick/warnings2/kernel/runtime/Utilities.cpp Modified: sandbox/rick/warnings2/kernel/classes/ClassClass.cpp =================================================================== --- sandbox/rick/warnings2/kernel/classes/ClassClass.cpp 2007-10-28 01:14:24 UTC (rev 1114) +++ sandbox/rick/warnings2/kernel/classes/ClassClass.cpp 2007-10-28 11:43:54 UTC (rev 1115) @@ -404,7 +404,7 @@ * creation, so we delay setting this attribute until the * class is fully constructed. */ -void RexxClass::subClassable(PCHAR class_id, bool restricted) +void RexxClass::subClassable(const char *class_id, bool restricted) { /* get a copy of the class instance */ /* behaviour mdict before the merge */ Modified: sandbox/rick/warnings2/kernel/classes/ClassClass.hpp =================================================================== --- sandbox/rick/warnings2/kernel/classes/ClassClass.hpp 2007-10-28 01:14:24 UTC (rev 1114) +++ sandbox/rick/warnings2/kernel/classes/ClassClass.hpp 2007-10-28 11:43:54 UTC (rev 1115) @@ -86,7 +86,7 @@ RexxTable *getInstanceBehaviourDictionary(); RexxTable *getBehaviourDictionary(); RexxString *defaultName(); - void subClassable(PCHAR, bool); + void subClassable(const char *, bool); RexxObject *defineMethod(RexxString *, RexxMethod *); RexxObject *defineMethods(RexxTable *); RexxObject *deleteMethod(RexxString *); Modified: sandbox/rick/warnings2/kernel/runtime/RexxNativeMethod.cpp =================================================================== --- sandbox/rick/warnings2/kernel/runtime/RexxNativeMethod.cpp 2007-10-28 01:14:24 UTC (rev 1114) +++ sandbox/rick/warnings2/kernel/runtime/RexxNativeMethod.cpp 2007-10-28 11:43:54 UTC (rev 1115) @@ -52,20 +52,20 @@ extern "C" internalMethodEntry internalMethodTable[]; RexxNativeCode::RexxNativeCode( - RexxString *procedure, /* procedure to load */ - RexxString *library, /* library to load from */ - PFN entry, /* Entry point address for method */ - LONG index ) /* internal method index */ + RexxString *_procedure, /* procedure to load */ + RexxString *_library, /* library to load from */ + PFN _entry, /* Entry point address for method */ + LONG _index ) /* internal method index */ /****************************************************************************/ /* Function: Initialize a REXX native code object */ /****************************************************************************/ { - this->entry = entry; /* no resolved entry point yet */ - this->index = index; /* save the index */ + this->entry = _entry; /* no resolved entry point yet */ + this->index = _index; /* save the index */ /* save the library name */ - OrefSet(this, this->library, library); + OrefSet(this, this->library, _library); /* save the procedure name */ - OrefSet(this, this->procedure, procedure); + OrefSet(this, this->procedure, _procedure); } void RexxNativeCode::reinit( /* reinitialize the nmethod entry */ @@ -203,8 +203,8 @@ } RexxNativeCode *RexxNativeCodeClass::newClass( - RexxString *procedure, /* procedure to load */ - RexxString *library ) /* library to load from */ + RexxString *_procedure, /* procedure to load */ + RexxString *_library ) /* library to load from */ /****************************************************************************/ /* Function: Create a new native method */ /****************************************************************************/ @@ -213,23 +213,23 @@ RexxDirectory *libinfo; /* Library info table for library */ PFN entry; /* routine entry point address */ - libinfo = this->load(library); /* Load the library. */ + libinfo = this->load(_library); /* Load the library. */ if (libinfo != OREF_NULL) { /* library loaded ok? */ /* See if we already know about this */ /* method. */ - newMethod = (RexxNativeCode *)libinfo->entry(procedure); + newMethod = (RexxNativeCode *)libinfo->entry(_procedure); if (newMethod == OREF_NULL) { /* not there yet? */ /* resolve the function address */ - entry = (PFN)SysLoadProcedure((RexxInteger *)libinfo->at(OREF_NULLSTRING), procedure); + entry = (PFN)SysLoadProcedure((RexxInteger *)libinfo->at(OREF_NULLSTRING), _procedure); /* unknown, create a new one. */ /* Get new object */ - newMethod = new RexxNativeCode (procedure, library, entry, 0); + newMethod = new RexxNativeCode (_procedure, _library, entry, 0); /* add this to the libraries table */ - libinfo->setEntry(procedure, (RexxObject *)newMethod); + libinfo->setEntry(_procedure, (RexxObject *)newMethod); } } else { - newMethod = new RexxNativeCode (procedure, library, NULL, 0); + newMethod = new RexxNativeCode (_procedure, _library, NULL, 0); } return (RexxNativeCode *)newMethod; /* return the new method */ } Modified: sandbox/rick/warnings2/kernel/runtime/RexxSOMProxy.cpp =================================================================== --- sandbox/rick/warnings2/kernel/runtime/RexxSOMProxy.cpp 2007-10-28 01:14:24 UTC (rev 1114) +++ sandbox/rick/warnings2/kernel/runtime/RexxSOMProxy.cpp 2007-10-28 11:43:54 UTC (rev 1115) @@ -478,9 +478,9 @@ /* Returned: self */ /******************************************************************************/ { - long longValue; - longValue = this->longValue(NO_LONG); - return new_integer(longValue); + long longVal; + longVal = this->longValue(NO_LONG); + return new_integer(longVal); } RexxObject *RexxSOMProxy::initProxy(RexxInteger *somobj) @@ -956,21 +956,21 @@ /* Function: Create a new integer object */ /******************************************************************************/ { - RexxSOMProxy *newObject; /* newly create object */ + RexxSOMProxy *newObj; /* newly create object */ /* get a new object */ - newObject = new RexxSOMProxy; + newObj = new RexxSOMProxy; /* add in the integer behaviour, and */ /* make sure old2new knows about it */ - BehaviourSet(newObject, this->instanceBehaviour); + BehaviourSet(newObj, this->instanceBehaviour); /* set the default hash value */ /* does object have an UNINT method */ if (this->uninitDefined()) { /* Make sure everyone is notified. */ - newObject->hasUninit(); + newObj->hasUninit(); } - return newObject; /* return the new object. */ + return newObj; /* return the new object. */ } Modified: sandbox/rick/warnings2/kernel/runtime/RexxVariableDictionary.cpp =================================================================== --- sandbox/rick/warnings2/kernel/runtime/RexxVariableDictionary.cpp 2007-10-28 01:14:24 UTC (rev 1114) +++ sandbox/rick/warnings2/kernel/runtime/RexxVariableDictionary.cpp 2007-10-28 11:43:54 UTC (rev 1115) @@ -59,21 +59,21 @@ /* Function: Copy a variable dictionary */ /******************************************************************************/ { - RexxVariableDictionary *copy; /* copied object */ + RexxVariableDictionary *copyObj; /* copied object */ /* create a new object */ - copy = new_variableDictionary(contents->mainSlotsSize()); - ClearObject(copy); /* clear this out */ + copyObj = new_variableDictionary(contents->mainSlotsSize()); + ClearObject(copyObj); /* clear this out */ /* copy the behaviour pointer */ - OrefSet(copy, copy->behaviour, this->behaviour); - save(copy); /* protect from garbage collect */ + OrefSet(copyObj, copyObj->behaviour, this->behaviour); + save(copyObj); /* protect from garbage collect */ /* copy the hash table */ - OrefSet(copy, copy->contents, (RexxHashTable *)this->contents->copy()); + OrefSet(copyObj, copyObj->contents, (RexxHashTable *)this->contents->copy()); /* make sure we copy the scope too */ - OrefSet(copy, copy->scope, this->scope); - copy->copyValues(); /* copy all of the variables */ - discard(hold(copy)); /* unlock the copy */ - return (RexxObject *)copy; /* return the new vdict */ + OrefSet(copyObj, copyObj->scope, this->scope); + copyObj->copyValues(); /* copy all of the variables */ + discard(hold(copyObj)); /* unlock the copy */ + return (RexxObject *)copyObj; /* return the new vdict */ } void RexxVariableDictionary::copyValues() @@ -83,15 +83,15 @@ { size_t i; /* loop counter */ RexxObject *value; /* hash table value */ - RexxObject *copy; /* copied value */ + RexxObject *copyObj; /* copied value */ /* loop through the hash table */ for (i = this->contents->first(); i < this->contents->totalSlotsSize(); i = this->contents->next(i)) { - value = this->contents->value(i); /* get the next value */ - copy = value->copy(); /* copy the value */ - this->contents->replace(copy, i); /* replace with the copied value */ + value = this->contents->value(i); /* get the next value */ + copyObj = value->copy(); /* copy the value */ + this->contents->replace(copyObj, i); /* replace with the copied value */ } } @@ -111,7 +111,7 @@ RexxCompoundElement *RexxVariableDictionary::getCompoundVariable( - RexxString *stem, /* name of stem for compound */ + RexxString *stemName, /* name of stem for compound */ RexxObject **tail, /* tail of the compound element */ LONG tailCount) /* number of tail pieces */ /******************************************************************************/ @@ -123,14 +123,14 @@ /* new tail for compound */ RexxCompoundTail resolved_tail(this, tail, tailCount); - stem_table = getStem(stem); /* get the stem entry from this dictionary */ + stem_table = getStem(stemName); /* get the stem entry from this dictionary */ /* get the compound variable */ return stem_table->getCompoundVariable(&resolved_tail); } RexxObject *RexxVariableDictionary::getCompoundVariableValue( - RexxString *stem, /* name of stem for compound */ + RexxString *stemName, /* name of stem for compound */ RexxObject **tail, /* tail of the compound element */ LONG tailCount) /* number of tail pieces */ /******************************************************************************/ @@ -142,7 +142,7 @@ /* new tail for compound */ RexxCompoundTail resolved_tail(this, tail, tailCount); - stem_table = getStem(stem); /* get the stem entry from this dictionary */ + stem_table = getStem(stemName); /* get the stem entry from this dictionary */ /* get the value from the stem...we pass OREF_NULL */ /* for the dictionary to bypass NOVALUE handling */ return stem_table->evaluateCompoundVariableValue(OREF_NULL, &resolved_tail); @@ -150,14 +150,14 @@ RexxObject *RexxVariableDictionary::realStemValue( - RexxString *stem) /* name of stem for compound */ + RexxString *stemName) /* name of stem for compound */ /******************************************************************************/ /* Function: Retrieve the "real" value of a stem variable. OREF_NULL is */ /* returned if the stem does not exist. */ /******************************************************************************/ { /* look up the name */ - return this->getStem(stem); /* find and return the stem directly */ + return this->getStem(stemName); /* find and return the stem directly */ } @@ -195,7 +195,7 @@ RexxVariable *RexxVariableDictionary::createStemVariable( - RexxString *stem) /* name of target stem */ + RexxString *stemName) /* name of target stem */ /******************************************************************************/ /* Function: Lookup and retrieve a STEM variable item (not the stem table) */ /* level) */ @@ -205,13 +205,13 @@ RexxVariable *variable; /* resolved variable item */ RexxHashTable *new_hash; /* reallocated hash table */ - variable = new_variable(stem); /* make a new variable entry */ - stemtable = new RexxStem (stem); /* create a stem object as value */ + variable = new_variable(stemName); /* make a new variable entry */ + stemtable = new RexxStem (stemName); /* create a stem object as value */ /* the stem object is the value of */ /* stem variable */ variable->set((RexxObject *)stemtable); /* try to place in existing hashtab */ - new_hash = this->contents->stringAdd((RexxObject *)variable, stem); + new_hash = this->contents->stringAdd((RexxObject *)variable, stemName); if (new_hash != OREF_NULL) /* have a reallocation occur? */ /* hook on the new hash table */ OrefSet(this, this->contents, new_hash); @@ -357,12 +357,12 @@ } -void RexxVariableDictionary::setNextDictionary(RexxVariableDictionary *next) +void RexxVariableDictionary::setNextDictionary(RexxVariableDictionary *_next) /******************************************************************************/ /* Function: Chain up a dictionary associated with an object */ /******************************************************************************/ { - OrefSet(this, this->next, next); + OrefSet(this, this->next, _next); } void RexxVariableDictionary::live() @@ -415,7 +415,7 @@ /* Function: Create a new translator object */ /******************************************************************************/ { - RexxVariableDictionary *newObject; /* newly created object */ + RexxVariableDictionary *newObj; /* newly created object */ size_t hashTabSize; /* size of hash table to allocate */ hashTabSize = looksize * 2; /* create entries for twice size */ @@ -428,12 +428,12 @@ /* some special optimization of the */ /* look ups */ /* get a new object and hash */ - newObject = (RexxVariableDictionary *)new_hashCollection(hashTabSize, sizeof(RexxVariableDictionary)); + newObj = (RexxVariableDictionary *)new_hashCollection(hashTabSize, sizeof(RexxVariableDictionary)); /* Give new object its behaviour */ - BehaviourSet(newObject, TheVariableDictionaryBehaviour); + BehaviourSet(newObj, TheVariableDictionaryBehaviour); /* set the virtual function table */ - setVirtualFunctions(newObject, T_vdict); - return newObject; /* return the new vdict */ + setVirtualFunctions(newObj, T_vdict); + return newObj; /* return the new vdict */ } @@ -443,7 +443,7 @@ /* Function: Create a new translator object */ /******************************************************************************/ { - RexxVariableDictionary *newObject; /* newly created object */ + RexxVariableDictionary *newObj; /* newly created object */ size_t hashTabSize; /* size of hash table to allocate */ /* create entries for twice size */ @@ -457,11 +457,11 @@ /* some special optimization of the */ /* look ups */ /* get a new object and hash */ - newObject = (RexxVariableDictionary *)new_hashCollection(hashTabSize, sizeof(RexxVariableDictionary)); - newObject->scope = scope; /* fill in the scope */ + newObj = (RexxVariableDictionary *)new_hashCollection(hashTabSize, sizeof(RexxVariableDictionary)); + newObj->scope = scope; /* fill in the scope */ /* Give new object its behaviour */ - BehaviourSet(newObject, TheVariableDictionaryBehaviour); + BehaviourSet(newObj, TheVariableDictionaryBehaviour); /* set the virtual function table */ - setVirtualFunctions(newObject, T_vdict); - return newObject; /* return the new vdict */ + setVirtualFunctions(newObj, T_vdict); + return newObj; /* return the new vdict */ } Modified: sandbox/rick/warnings2/kernel/runtime/Setup.cpp =================================================================== --- sandbox/rick/warnings2/kernel/runtime/Setup.cpp 2007-10-28 01:14:24 UTC (rev 1114) +++ sandbox/rick/warnings2/kernel/runtime/Setup.cpp 2007-10-28 11:43:54 UTC (rev 1115) @@ -546,13 +546,13 @@ NULL /* final terminating method */ }; -LONG resolveExportedMethod( +size_t resolveExportedMethod( PCPPM targetMethod ) /* method needed to resolve */ /******************************************************************************/ /* Function: Resolve a method address to numeric index */ /******************************************************************************/ { - LONG i; /* loop counter */ + size_t i; /* loop counter */ if (targetMethod == NULL) /* unresolved method address? */ /* this is a bad error */ @@ -633,11 +633,9 @@ memoryObject.enableOrefChecks(); /* enable setCheckOrefs... */ } -LONG resolveExportedMethod(PCPPM); - RexxMethod * createKernelMethod( PCPPM entryPoint, /* method entry point */ - LONG arguments) /* count of arguments */ + size_t arguments) /* count of arguments */ /******************************************************************************/ /* Function: Create a primitive, C++ method object */ /******************************************************************************/ @@ -648,7 +646,7 @@ RexxMethod * createProtectedKernelMethod( PCPPM entryPoint, /* method entry point */ - LONG arguments) /* count of arguments */ + size_t arguments) /* count of arguments */ /******************************************************************************/ /* Function: Create a primitive, C++ method object */ /******************************************************************************/ @@ -662,7 +660,7 @@ RexxMethod * createPrivateKernelMethod( PCPPM entryPoint, /* method entry point */ - LONG arguments) /* count of arguments */ + size_t arguments) /* count of arguments */ /******************************************************************************/ /* Function: Create a primitive, C++ method object */ /******************************************************************************/ @@ -679,7 +677,7 @@ char * name, /* ASCII-Z name for the method */ RexxBehaviour * behaviour, /* behaviour to use */ PCPPM entryPoint, /* method's entry point */ - LONG arguments ) /* count of arguments */ + size_t arguments ) /* count of arguments */ /******************************************************************************/ /* Function: Add a C++ method to an object's behaviour */ /******************************************************************************/ @@ -1623,8 +1621,10 @@ } /* create a method object out of this*/ meth = TheMethodClass->newFile(programName); + + RexxObject *args = kernel_methods; // temporary to avoid type-punning warnings /* now call BaseClasses to finish the image*/ - ((RexxObject *)CurrentActivity)->shriekRun(meth, OREF_NULL, OREF_NULL, (RexxObject **)&kernel_methods, 1); + ((RexxObject *)CurrentActivity)->shriekRun(meth, OREF_NULL, OREF_NULL, (RexxObject **)&args, 1); discard(kernel_methods); /* release the directory lock */ /* define and suppress methods in the nil object */ Modified: sandbox/rick/warnings2/kernel/runtime/Utilities.cpp =================================================================== --- sandbox/rick/warnings2/kernel/runtime/Utilities.cpp 2007-10-28 01:14:24 UTC (rev 1114) +++ sandbox/rick/warnings2/kernel/runtime/Utilities.cpp 2007-10-28 11:43:54 UTC (rev 1115) @@ -105,7 +105,7 @@ primary = (new_string(errorcode->getStringData(), count)->longValue(9)) * 1000; /* did major code compute to long */ /* and within range */ - if (primary == NO_LONG || primary < 1 || primary >= 100000) { + if (primary == (int)NO_LONG || primary < 1 || primary >= 100000) { /* Nope raise an error. */ report_exception(Error_Expression_result_raise); } @@ -114,7 +114,7 @@ /* Yes, compute its decimal value. */ secondary = new_string(decimalPoint + 1, errorcode->getLength() - count -1)->longValue(9); /* is the subcode invalid or too big?*/ - if (secondary == NO_LONG || secondary < 0 || secondary >= 1000) { + if (secondary == (int)NO_LONG || secondary < 0 || secondary >= 1000) { /* Yes, raise an error. */ report_exception(Error_Expression_result_raise); } This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |