From: <bi...@us...> - 2007-10-22 22:49:53
|
Revision: 1060 http://oorexx.svn.sourceforge.net/oorexx/?rev=1060&view=rev Author: bigrixx Date: 2007-10-22 15:49:57 -0700 (Mon, 22 Oct 2007) Log Message: ----------- Another merge of warning removals back into trunk. Modified Paths: -------------- interpreter-3.x/trunk/kernel/classes/ArrayClass.cpp interpreter-3.x/trunk/kernel/classes/ClassClass.cpp interpreter-3.x/trunk/kernel/classes/ListClass.cpp interpreter-3.x/trunk/kernel/classes/ListClass.hpp interpreter-3.x/trunk/kernel/classes/MessageClass.cpp interpreter-3.x/trunk/kernel/classes/MethodClass.cpp interpreter-3.x/trunk/kernel/classes/MethodClass.hpp interpreter-3.x/trunk/kernel/classes/MutableBufferClass.cpp interpreter-3.x/trunk/kernel/classes/NumberStringClass.cpp interpreter-3.x/trunk/kernel/classes/NumberStringClass.hpp interpreter-3.x/trunk/kernel/classes/ObjectClass.cpp interpreter-3.x/trunk/kernel/classes/QueueClass.cpp interpreter-3.x/trunk/kernel/classes/QueueClass.hpp interpreter-3.x/trunk/kernel/classes/RelationClass.cpp interpreter-3.x/trunk/kernel/classes/StackClass.cpp interpreter-3.x/trunk/kernel/classes/StemClass.cpp interpreter-3.x/trunk/kernel/classes/StringClass.cpp interpreter-3.x/trunk/kernel/classes/StringClassBit.cpp interpreter-3.x/trunk/kernel/classes/StringClassConversion.cpp interpreter-3.x/trunk/kernel/classes/StringClassMisc.cpp interpreter-3.x/trunk/kernel/classes/StringClassSub.cpp interpreter-3.x/trunk/kernel/classes/StringClassUtil.cpp interpreter-3.x/trunk/kernel/classes/SupplierClass.cpp interpreter-3.x/trunk/kernel/classes/TableClass.cpp interpreter-3.x/trunk/kernel/expression/ExpressionCompoundVariable.cpp interpreter-3.x/trunk/kernel/expression/ExpressionMessage.cpp interpreter-3.x/trunk/kernel/expression/ExpressionOperator.cpp interpreter-3.x/trunk/kernel/expression/ExpressionOperator.hpp interpreter-3.x/trunk/kernel/expression/ExpressionStack.cpp interpreter-3.x/trunk/kernel/expression/ExpressionStem.cpp interpreter-3.x/trunk/kernel/expression/ExpressionVariable.cpp interpreter-3.x/trunk/kernel/instructions/AddressInstruction.cpp interpreter-3.x/trunk/kernel/instructions/AssignmentInstruction.cpp interpreter-3.x/trunk/kernel/instructions/CommandInstruction.cpp interpreter-3.x/trunk/kernel/instructions/DropInstruction.cpp interpreter-3.x/trunk/kernel/instructions/ExitInstruction.cpp interpreter-3.x/trunk/kernel/instructions/GuardInstruction.cpp interpreter-3.x/trunk/kernel/instructions/GuardInstruction.hpp interpreter-3.x/trunk/kernel/instructions/IfInstruction.cpp interpreter-3.x/trunk/kernel/instructions/InterpretInstruction.cpp interpreter-3.x/trunk/kernel/instructions/LeaveInstruction.cpp interpreter-3.x/trunk/kernel/instructions/LeaveInstruction.hpp interpreter-3.x/trunk/kernel/instructions/ParseInstruction.cpp interpreter-3.x/trunk/kernel/instructions/QueueInstruction.cpp interpreter-3.x/trunk/kernel/instructions/QueueInstruction.hpp interpreter-3.x/trunk/kernel/instructions/ReplyInstruction.cpp interpreter-3.x/trunk/kernel/instructions/ReturnInstruction.cpp interpreter-3.x/trunk/kernel/instructions/RexxInstruction.hpp interpreter-3.x/trunk/kernel/instructions/SayInstruction.cpp interpreter-3.x/trunk/kernel/instructions/SignalInstruction.cpp interpreter-3.x/trunk/kernel/instructions/SignalInstruction.hpp interpreter-3.x/trunk/kernel/instructions/ThenInstruction.cpp interpreter-3.x/trunk/kernel/instructions/TraceInstruction.cpp interpreter-3.x/trunk/kernel/parser/Clause.cpp interpreter-3.x/trunk/kernel/parser/Clause.hpp interpreter-3.x/trunk/kernel/parser/InstructionParser.cpp interpreter-3.x/trunk/kernel/parser/KeywordConstants.cpp interpreter-3.x/trunk/kernel/parser/SourceFile.cpp interpreter-3.x/trunk/kernel/parser/SourceFile.hpp interpreter-3.x/trunk/kernel/parser/Token.hpp interpreter-3.x/trunk/kernel/platform/unix/ErrorMessages.cpp interpreter-3.x/trunk/kernel/runtime/GlobalData.cpp interpreter-3.x/trunk/kernel/runtime/RexxCore.h interpreter-3.x/trunk/kernel/runtime/RexxListTable.cpp interpreter-3.x/trunk/kernel/runtime/RexxListTable.hpp interpreter-3.x/trunk/kernel/runtime/RexxNativeActivation.hpp Modified: interpreter-3.x/trunk/kernel/classes/ArrayClass.cpp =================================================================== --- interpreter-3.x/trunk/kernel/classes/ArrayClass.cpp 2007-10-22 22:43:38 UTC (rev 1059) +++ interpreter-3.x/trunk/kernel/classes/ArrayClass.cpp 2007-10-22 22:49:57 UTC (rev 1060) @@ -2217,7 +2217,7 @@ } wholenumber_t comparison = result->longValue(DEFAULT_DIGITS); - if (comparison == NO_LONG) + if (comparison == (wholenumber_t)NO_LONG) { reportException(Error_Invalid_whole_number_compare, result); } Modified: interpreter-3.x/trunk/kernel/classes/ClassClass.cpp =================================================================== --- interpreter-3.x/trunk/kernel/classes/ClassClass.cpp 2007-10-22 22:43:38 UTC (rev 1059) +++ interpreter-3.x/trunk/kernel/classes/ClassClass.cpp 2007-10-22 22:49:57 UTC (rev 1060) @@ -279,12 +279,12 @@ } void RexxClass::setInstanceBehaviour( - RexxBehaviour *behaviour) /* new instance behaviour */ + RexxBehaviour *b) /* new instance behaviour */ /*****************************************************************************/ /* Function: Give a class a new instance behaviour */ /*****************************************************************************/ { - OrefSet(this, this->instanceBehaviour, behaviour); + OrefSet(this, this->instanceBehaviour, b); } RexxClass *RexxClass::getSuperClass() @@ -330,7 +330,7 @@ } void RexxClass::defmeths( - RexxTable *methods) /* methods to add */ + RexxTable *newMethods) /* methods to add */ /*****************************************************************************/ /* Function: Add a table of methods to a primitive class behaviour */ /*****************************************************************************/ @@ -339,12 +339,12 @@ RexxString * method_name; /* name of an added method */ /* loop through the list of methods */ - for (i = methods->first(); methods->available(i); i = methods->next(i)) { + for (i = newMethods->first(); newMethods->available(i); i = newMethods->next(i)) { /* get the method name */ - method_name = (RexxString *)methods->index(i); + method_name = (RexxString *)newMethods->index(i); /* add this method to the classes */ /* class behaviour */ - this->behaviour->define(method_name, (RexxMethod *)methods->value(i)); + this->behaviour->define(method_name, (RexxMethod *)newMethods->value(i)); } } @@ -368,15 +368,15 @@ /* Function: Return the instance behaviour's method dictionary */ /*****************************************************************************/ { - RexxTable *methods; /* returned method dictioanry */ + RexxTable *methodTable; /* returned method dictioanry */ /* get the method dictionary */ - methods = this->instanceBehaviour->getMethodDictionary(); - if (methods == OREF_NULL) /* no methods defined yet? */ + methodTable = this->instanceBehaviour->getMethodDictionary(); + if (methodTable == OREF_NULL) /* no methods defined yet? */ return new_table(); /* create a new method table */ else /* just copy the method dictionary */ - return (RexxTable *)methods->copy(); + return (RexxTable *)methodTable->copy(); } RexxTable *RexxClass::getBehaviourDictionary() @@ -384,15 +384,15 @@ /* Function: Return the class behaviour's method dictionary */ /*****************************************************************************/ { - RexxTable *methods; /* returned method dictioanry */ + RexxTable *methodTable; /* returned method dictioanry */ /* get the method dictionary */ - methods = this->behaviour->getMethodDictionary(); - if (methods == OREF_NULL) /* no methods defined yet? */ + methodTable = this->behaviour->getMethodDictionary(); + if (methodTable == OREF_NULL) /* no methods defined yet? */ return new_table(); /* create a new method table */ else /* just copy the method dictionary */ - return (RexxTable *)methods->copy(); + return (RexxTable *)methodTable->copy(); } /** @@ -580,25 +580,25 @@ } RexxObject *RexxClass::defineMethods( - RexxTable * methods) /* new table of methods to define */ + RexxTable * newMethods) /* new table of methods to define */ /*****************************************************************************/ /* Function: Define instance methods on this class object */ /*****************************************************************************/ { long i; /* loop counter */ RexxString * index; /* method name */ - RexxMethod * method; /* new method to process */ + RexxMethod * newMethod; /* new method to process */ /* loop thru the methods setting the */ /* method scopes to SELF and then */ /* adding them to SELF's instance */ /* mdict */ - for (i = methods->first(); (index = (RexxString *)methods->index(i)) != OREF_NULL; i = methods->next(i)) { + for (i = newMethods->first(); (index = (RexxString *)newMethods->index(i)) != OREF_NULL; i = newMethods->next(i)) { /* get the method */ - method = (RexxMethod *)methods->value(i); - if (OTYPE(Method, method)) /* if this is a method object */ - method->setScope(this); /* change the scope */ + newMethod = (RexxMethod *)newMethods->value(i); + if (OTYPE(Method, newMethod)) /* if this is a method object */ + newMethod->setScope(this); /* change the scope */ /* add method to the instance mdict */ - this->instanceMethodDictionary->stringPut(method, index); + this->instanceMethodDictionary->stringPut(newMethod, index); /* Installing UNINIT? */ if (index->strCompare(CHAR_UNINIT)) { this->class_info |= HAS_UNINIT; /* and turn on uninit if so */ @@ -615,7 +615,7 @@ /* that will be imported */ if ((this->somClass != (RexxInteger *)TheNilObject) && !(this->class_info & IMPORTED)) { /* loop through the list of methods */ - for (i = methods->first(); (index = (RexxString *)methods->index(i)) != OREF_NULL; i = methods->next(i)) { + for (i = newMethods->first(); (index = (RexxString *)newMethods->index(i)) != OREF_NULL; i = newMethods->next(i)) { /* define the methods as som methods */ this->somDefine(index, this->somClass); } @@ -873,9 +873,9 @@ /*****************************************************************************/ { - RexxMethod *method; /* method to be added */ + RexxMethod *method_instance; /* method to be added */ RexxString *method_name; /* method name to be added */ - LONG i; /* table index for traversal */ + HashLink i; /* table index for traversal */ if (source_mdict == OREF_NULL) /* check for a source mdict */ return; /* there isn't anything to do */ @@ -884,9 +884,9 @@ /* get the method name */ method_name = REQUEST_STRING(source_mdict->index(i)); /* get the method */ - method = (RexxMethod *)source_mdict->value(i); + method_instance = (RexxMethod *)source_mdict->value(i); /* add the method to the target mdict */ - target_mdict->stringAdd(method, method_name); + target_mdict->stringAdd(method_instance, method_name); /* check if the method that was added */ /* is the uninit method */ if ( method_name->strCompare(CHAR_UNINIT)) @@ -905,7 +905,7 @@ /*****************************************************************************/ { RexxTable *newDictionary; /* returned merged mdict */ - RexxMethod *method; /* method to be added */ + RexxMethod *newMethod; /* method to be added */ RexxString *method_name; /* method name to be added */ RexxSupplier *supplier; /* working supplier object */ @@ -919,23 +919,23 @@ /* get the method name (uppercased) */ method_name = REQUEST_STRING(supplier->index())->upper(); /* get the method */ - method = (RexxMethod *)supplier->value(); + newMethod = (RexxMethod *)supplier->value(); /* if the method is not TheNilObject */ - if (method != (RexxMethod *)TheNilObject) { + if (newMethod != (RexxMethod *)TheNilObject) { /* and it isn't a primitive method */ - if (!OTYPE(Method, method)) { /* object */ + if (!OTYPE(Method, newMethod)) { /* object */ /* make it into a method object */ - method = TheMethodClass->newRexxCode(method_name, method, IntegerOne); - method->setScope(scope); /* and set the scope to the given */ + newMethod = TheMethodClass->newRexxCode(method_name, newMethod, IntegerOne); + newMethod->setScope(scope); /* and set the scope to the given */ } else { /* if it is a primitive method object */ /* let the newscope method copy it */ - method = method->newScope(scope); + newMethod = newMethod->newScope(scope); } } /* add the method to the target mdict */ - newDictionary->stringAdd(method, method_name); + newDictionary->stringAdd(newMethod, method_name); } discard(supplier); /* done with the supplier */ discard_hold(newDictionary); /* and also the dictionary */ @@ -1000,9 +1000,9 @@ /* or the specified position (parameter two). */ /*****************************************************************************/ { - LONG class_index; /* index for class superclasses list */ - LONG instance_index; /* index for instance superclasses */ - long i; /* loop counter */ + HashLink class_index; /* index for class superclasses list */ + HashLink instance_index; /* index for instance superclasses */ + HashLink i; /* loop counter */ /* make sure this isn't a rexx */ if (this->rexxDefined()) /* defined class being changed */ /* report as a nomethod condition */ @@ -1053,10 +1053,13 @@ /* in the class superclasses list */ /* and the reciever's */ /* instance superclasses list */ - if (((class_index = this->classSuperClasses->indexOf(position)) == 0) || - ((instance_index = this->instanceSuperClasses->indexOf(position)) == 0)) + class_index = this->classSuperClasses->indexOf(position); + instance_index = this->instanceSuperClasses->indexOf(position); + if (class_index == 0 || instance_index == 0) + { /* if it isn't raise an error */ - report_exception2(Error_Execution_uninherit, this, position); + report_exception2(Error_Execution_uninherit, this, position); + } /* insert the mixin class into the */ /* superclasses list's */ this->classSuperClasses->insertItem(mixin_class, class_index + 1); @@ -1174,7 +1177,7 @@ } RexxClass *RexxClass::mixinclass( - RexxString * id, /* ID name of the class */ + RexxString * mixin_id, /* ID name of the class */ RexxClass * meta_class, /* source meta class */ /* extra class methods */ RexxTable * enhancing_class_methods) @@ -1185,7 +1188,7 @@ { RexxClass * mixin_subclass; /* new mixin subclass */ /* call subclass with the parameters */ - mixin_subclass = this->subclass(id, meta_class, enhancing_class_methods); + mixin_subclass = this->subclass(mixin_id, meta_class, enhancing_class_methods); mixin_subclass->setMixinClass(); /* turn on the mixin info */ /* change the base class to the base */ /* class of the reciever */ @@ -1199,7 +1202,7 @@ RexxClass *RexxClass::subclass( - RexxString * id, /* ID name of the class */ + RexxString * class_id, /* ID name of the class */ RexxClass * meta_class, /* source meta class */ /* extra class methods */ RexxTable * enhancing_class_methods) @@ -1216,7 +1219,7 @@ if (!meta_class->queryMeta()) /* check that it is a meta class */ report_exception1(Error_Translation_bad_metaclass, meta_class); /* get a copy of the metaclass class */ - new_class = (RexxClass *)save(meta_class->sendMessage(OREF_NEW, id)); + new_class = (RexxClass *)save(meta_class->sendMessage(OREF_NEW, class_id)); new_class->hashvalue = HASHOREF(new_class); if (this->queryMeta()) { /* if the superclass is a metaclass */ new_class->setMeta(); /* mark the new class as a meta class*/ @@ -1305,7 +1308,7 @@ RexxClass *RexxClass::external( RexxString *externalString, /* external class name */ - RexxClass *metaClass, /* external meta class */ + RexxClass *source_metaClass, /* external meta class */ RexxTable *enhancingClassMethods) /* additional CLass methods */ /******************************************************************************/ /* Function: Process an external class definition */ @@ -1353,7 +1356,7 @@ if (classModel->strCompare(CHAR_SOM)) { /* Yes, then import from localserver */ - externalClass = (RexxClass *)ProcessLocalServer->sendMessage(OREF_IMPORT, className, metaClass, enhancingClassMethods); + externalClass = (RexxClass *)ProcessLocalServer->sendMessage(OREF_IMPORT, className, source_metaClass, enhancingClassMethods); } /* Not SOM, is it WPS? */ else if (classModel->strCompare(CHAR_WPS)) { @@ -1361,7 +1364,7 @@ classServer = TheEnvironment->at(OREF_WPS); if (OREF_NULL != classServer) { /* Yes, import the class through WPS */ - externalClass = (RexxClass *)classServer->sendMessage(OREF_IMPORT, className, metaClass, enhancingClassMethods); + externalClass = (RexxClass *)classServer->sendMessage(OREF_IMPORT, className, source_metaClass, enhancingClassMethods); } else report_exception1(Error_Execution_class_server_not_installed, classModel); @@ -1377,7 +1380,7 @@ discard_hold(className); /* done with perm hold, on classname */ } /* now load up the class through DSOM*/ - externalClass = (RexxClass *)classServer->sendMessage(OREF_IMPORT, className, metaClass, enhancingClassMethods); + externalClass = (RexxClass *)classServer->sendMessage(OREF_IMPORT, className, source_metaClass, enhancingClassMethods); } else report_exception1(Error_Translation_class_external_bad_class_server, classModel); @@ -1549,7 +1552,7 @@ RexxString *cid, /* class ID */ RexxString *sId, /* super class ID */ long numMeths, /* number of static methods */ - RexxClass *metaClass) /* SOM meta class */ + RexxClass *som_metaClass) /* SOM meta class */ /******************************************************************************/ /* Function: Export a SOM method */ /******************************************************************************/ @@ -1596,12 +1599,12 @@ } /* create the SOM class */ - if (metaClass == TheNilObject) { + if (som_metaClass == TheNilObject) { /* use parent's metaclass */ mclsobj = (SOMClass *)SOM_GetClass(pclsobj); } else { - mclass = metaClass->somClass; + mclass = som_metaClass->somClass; mclsobj = (SOMClass *)mclass->value; } classobj = (SOMClass *)mclsobj->somNew(); @@ -1707,37 +1710,37 @@ /* */ /******************************************************************************/ { - RexxSOMProxy * newObject; /* newly created object */ + RexxSOMProxy * newProxy; /* newly created object */ /* create new object REXX object */ - newObject = new RexxSOMProxy; + newProxy = new RexxSOMProxy; /* Set the behaviour */ - BehaviourSet(newObject, this->instanceBehaviour); + BehaviourSet(newProxy, this->instanceBehaviour); /* does object have an UNINT method */ if (this->uninitDefined()) { /* Make sure everyone is notified. */ - newObject->hasUninit(); + newProxy->hasUninit(); } /* initalize the Proxy portion */ - newObject->initProxy(somObj); - return newObject; /* return new object. */ + newProxy->initProxy(somObj); + return newProxy; /* return new object. */ } void RexxClass::setMetaClass( - RexxClass *metaClass ) /* new meta class to add */ + RexxClass *new_metaClass ) /* new meta class to add */ /******************************************************************************/ /* Function: Set a metaclass for a class */ /******************************************************************************/ { OrefSet(this, this->metaClass, new_array1(TheClassClass)); - this->metaClass->addFirst(metaClass); + this->metaClass->addFirst(new_metaClass); /* the metaclass mdict list */ OrefSet(this, this->metaClassMethodDictionary, new_array1(TheClassClass->instanceMethodDictionary->copy())); - this->metaClassMethodDictionary->addFirst(metaClass->instanceMethodDictionary); + this->metaClassMethodDictionary->addFirst(new_metaClass->instanceMethodDictionary); /* and the metaclass scopes list */ OrefSet(this, this->metaClassScopes, (RexxObjectTable *)TheClassClass->behaviour->scopes->copy()); /* add the scope list for this scope */ - this->metaClassScopes->add(metaClass, TheNilObject); - this->metaClassScopes->add(this->metaClassScopes->allAt(TheNilObject), metaClass); + this->metaClassScopes->add(new_metaClass, TheNilObject); + this->metaClassScopes->add(this->metaClassScopes->allAt(TheNilObject), new_metaClass); } @@ -1842,12 +1845,12 @@ /*****************************************************************************/ { RexxClass * new_class; /* holder for the new class */ - RexxString * id; /* id parameter */ + RexxString * class_id; /* id parameter */ if (argCount == 0) /* make sure an arg was passed in */ /* if not report an error */ report_exception1(Error_Incorrect_method_minarg, IntegerOne); - id = (RexxString *)args[0]; /* get the id parameter */ - id = REQUIRED_STRING(id, ARG_ONE); /* and that it can be a string */ + class_id = (RexxString *)args[0]; /* get the id parameter */ + class_id = REQUIRED_STRING(class_id, ARG_ONE); /* and that it can be a string */ /* get a copy of this class object */ new_class = (RexxClass *)memoryObject.clone(this); /* update cloned hashvalue */ @@ -1913,7 +1916,7 @@ /* set the som class to .nil */ OrefSet(new_class, new_class->somClass, (RexxInteger *)TheNilObject); /* set the id into the class object */ - OrefSet(new_class, new_class->id, id); + OrefSet(new_class, new_class->id, class_id); /* clear the info area except for */ /* uninit and imported */ new_class->class_info &= (HAS_UNINIT & IMPORTED); Modified: interpreter-3.x/trunk/kernel/classes/ListClass.cpp =================================================================== --- interpreter-3.x/trunk/kernel/classes/ListClass.cpp 2007-10-22 22:43:38 UTC (rev 1059) +++ interpreter-3.x/trunk/kernel/classes/ListClass.cpp 2007-10-22 22:49:57 UTC (rev 1060) @@ -75,20 +75,20 @@ } void RexxList::partitionBuffer( - long first, /* first entry location */ - long count ) /* entries to partition */ + size_t first_entry, /* first entry location */ + size_t entry_count ) /* entries to partition */ /******************************************************************************/ /* Function: Partition a buffer up into a chain of free elements and set */ /* this up as the free element chain */ /******************************************************************************/ { - long i; /* loop counter */ + size_t i; /* loop counter */ LISTENTRY *element; /* working list element */ - this->free = first; /* set the new free chain head */ - i = first; /* get a loop counter */ + this->free = first_entry; /* set the new free chain head */ + i = first_entry; /* get a loop counter */ element = ENTRY_POINTER(i); /* point to the first element */ - while (count--) { + while (entry_count-- > 0) { /* zero the element value */ OrefSet(this->table, element->value, OREF_NULL); element->next = ++i; /* set the next element pointer */ @@ -99,7 +99,7 @@ element->next = LIST_END; /* set the terminator */ } -long RexxList::getFree(void) +size_t RexxList::getFree(void) /******************************************************************************/ /* Function: Check that we have at least one element on the free chain, and */ /* if not, expand our buffer size to add some space. */ @@ -107,8 +107,8 @@ { RexxListTable *newLTable; /* new allocated buffer */ LISTENTRY *element; /* current working element */ - long new_index; /* return index value */ - long i; /* loop counter */ + size_t new_index; /* return index value */ + size_t i; /* loop counter */ if (this->free == LIST_END) { /* no free elements? */ /* allocate a larger table */ @@ -175,29 +175,29 @@ } LISTENTRY * RexxList::getEntry( - RexxObject *index, /* list index item */ + RexxObject *_index, /* list index item */ RexxObject *position) /* index argument error position */ /******************************************************************************/ /* Function: Resolve a list index argument to a list element position */ /******************************************************************************/ { RexxInteger *integer_index; /* requested integer index */ - LONG item_index; /* converted item number */ + size_t item_index; /* converted item number */ LISTENTRY *element; /* located list element */ - if (index == OREF_NULL) /* must have one here */ + if (_index == OREF_NULL) /* must have one here */ /* else an error */ report_exception1(Error_Incorrect_method_noarg, position); /* force to integer form */ - integer_index = (RexxInteger *)REQUEST_INTEGER(index); + integer_index = (RexxInteger *)REQUEST_INTEGER(_index); if (integer_index == TheNilObject) /* doesn't exist? */ /* raise an exception */ - report_exception1(Error_Incorrect_method_index, index); + report_exception1(Error_Incorrect_method_index, _index); /* get the binary value */ item_index = integer_index->getValue(); if (item_index < 0) /* not a valid index? */ /* raise an exception */ - report_exception1(Error_Incorrect_method_index, index); + report_exception1(Error_Incorrect_method_index, _index); if (item_index >= this->size) /* out of possible range? */ return NULL; /* not found */ element = ENTRY_POINTER(item_index); /* point to the item */ @@ -207,7 +207,7 @@ } RexxObject *RexxList::value( - RexxObject *index) /* list index item */ + RexxObject *_index) /* list index item */ /******************************************************************************/ /* Function: Retrieve the value for a given list index */ /******************************************************************************/ @@ -216,7 +216,7 @@ RexxObject *result; /* returned result */ /* locate this entry */ - element = this->getEntry(index, (RexxObject *)IntegerOne); + element = this->getEntry(_index, (RexxObject *)IntegerOne); if (element == NULL) /* not there? */ return TheNilObject; /* doesn't exist, return .NIL */ result = element->value; /* get the value */ @@ -226,8 +226,8 @@ } RexxObject *RexxList::put( - RexxObject *value, /* new value for the item */ - RexxObject *index ) /* index of item to replace */ + RexxObject *_value, /* new value for the item */ + RexxObject *_index ) /* index of item to replace */ /******************************************************************************/ /* Function: Replace the value of an item already in the list. */ /******************************************************************************/ @@ -235,38 +235,38 @@ LISTENTRY *element; /* list element */ /* locate this entry */ - element = this->getEntry(index, (RexxObject *)IntegerTwo); - required_arg(value, ONE); /* must have a value also */ + element = this->getEntry(_index, (RexxObject *)IntegerTwo); + required_arg(_value, ONE); /* must have a value also */ if (element == NULL) /* not a valid index? */ /* raise an error */ - report_exception1(Error_Incorrect_method_index, index); + report_exception1(Error_Incorrect_method_index, _index); /* replace the value */ - OrefSet(this->table, element->value, value); + OrefSet(this->table, element->value, _value); return OREF_NULL; /* return nothing at all */ } RexxObject *RexxList::section( - RexxObject *index, /* index of starting item */ - RexxObject *count ) /* count of items to return */ + RexxObject *_index, /* index of starting item */ + RexxObject *_count ) /* count of items to return */ /******************************************************************************/ /* Function: Create a sublist of this list */ /******************************************************************************/ { LISTENTRY *element; /* list element */ - LONG counter; /* object counter */ + size_t counter; /* object counter */ RexxList *result; /* result list */ /* locate this entry */ - element = this->getEntry(index, (RexxObject *)IntegerOne); - if (count != OREF_NULL) { /* have a count? */ + element = this->getEntry(_index, (RexxObject *)IntegerOne); + if (_count != OREF_NULL) { /* have a count? */ /* Make sure it's a good integer */ - counter = count->requiredNonNegative(ARG_TWO); + counter = _count->requiredNonNegative(ARG_TWO); } else counter = 999999999; /* just use largest possible count */ if (element == NULL) /* index doesn't exist? */ /* raise an error */ - report_exception1(Error_Incorrect_method_index, index); + report_exception1(Error_Incorrect_method_index, _index); if (!OTYPE(List, this)) /* actually a list subclass? */ /* need to do this the slow way */ return this->sectionSubclass(element, counter); @@ -274,7 +274,7 @@ save(result); /* protect this */ /* while still more to go and not at */ /* the end of the list */ - while (counter--) { /* while still more items */ + while (counter--> 0) { /* while still more items */ /* add the this item to new list */ result->addLast(element->value); if (element->next == LIST_END) /* this the last one? */ @@ -288,7 +288,7 @@ RexxObject *RexxList::sectionSubclass( LISTENTRY *element, /* starting element */ - LONG counter) /* count of elements */ + size_t counter) /* count of elements */ /******************************************************************************/ /* Function: Rexx level section method */ /******************************************************************************/ @@ -300,7 +300,7 @@ save(newList); /* protect this */ /* while still more to go and not at */ /* the end of the list */ - while (counter--) { /* while still more items */ + while (counter-- > 0) { /* while still more items */ /* add the this item to new list */ newList->sendMessage(OREF_INSERT, element->value); if (element->next == LIST_END) /* this the last one? */ @@ -313,8 +313,8 @@ } RexxObject *RexxList::add( - RexxObject *value, /* new value to add */ - RexxObject *index) /* addition insertion index */ + RexxObject *_value, /* new value to add */ + RexxObject *_index) /* addition insertion index */ /******************************************************************************/ /* Function: Add a new element to the list at the given insertion point. */ /* TheNilObject indicates it should be added to the list end */ @@ -322,24 +322,24 @@ { LISTENTRY *new_element; /* new insertion element */ LISTENTRY *element; /* list element */ - long new_index; /* index of new inserted item */ + size_t new_index; /* index of new inserted item */ /* make sure we have room to insert */ new_index = this->getFree(); /* point to the actual element */ new_element = ENTRY_POINTER(new_index); - if (index == TheNilObject) /* inserting at the end? */ + if (_index == TheNilObject) /* inserting at the end? */ element = NULL; /* flag this as new */ else { /* locate this entry */ - element = this->getEntry(index, (RexxObject *)IntegerOne); + element = this->getEntry(_index, (RexxObject *)IntegerOne); if (element == NULL) /* index doesn't exist? */ /* raise an error */ - report_exception1(Error_Incorrect_method_index, index); + report_exception1(Error_Incorrect_method_index, _index); } this->count++; /* increase our count */ /* set the value */ - OrefSet(this->table, new_element->value, value); + OrefSet(this->table, new_element->value, _value); if (element == NULL) { /* adding at the end */ if (this->last == LIST_END) { /* first element added? */ this->first = new_index; /* set this as the first */ @@ -376,13 +376,13 @@ } void RexxList::addLast( - RexxObject *value ) /* new value to add */ + RexxObject *_value ) /* new value to add */ /******************************************************************************/ /* Function: Add a new element to the tail of a list */ /******************************************************************************/ { LISTENTRY *new_element; /* new insertion element */ - long new_index; /* index of new inserted item */ + size_t new_index; /* index of new inserted item */ /* make sure we have room to insert */ new_index = this->getFree(); @@ -390,7 +390,7 @@ new_element = ENTRY_POINTER(new_index); this->count++; /* increase our count */ /* set the value */ - OrefSet(this->table, new_element->value, value); + OrefSet(this->table, new_element->value, _value); if (this->last == LIST_END) { /* first element added? */ this->first = new_index; /* set this as the first */ this->last = new_index; /* and the last */ @@ -408,14 +408,14 @@ } void RexxList::addFirst( - RexxObject *value) /* new value to add */ + RexxObject *_value) /* new value to add */ /******************************************************************************/ /* Function: Insert an element at the front of the list */ /******************************************************************************/ { LISTENTRY *element; /* list element */ LISTENTRY *new_element; /* new insertion element */ - long new_index; /* index of new inserted item */ + size_t new_index; /* index of new inserted item */ new_index = this->getFree(); /* make sure we have room to insert */ @@ -423,7 +423,7 @@ new_element = ENTRY_POINTER(new_index); this->count++; /* increase our count */ /* set the value */ - OrefSet(this->table, new_element->value, value); + OrefSet(this->table, new_element->value, _value); if (this->last == LIST_END) { /* first element added? */ this->first = new_index; /* set this as the first */ this->last = new_index; /* and the last */ @@ -443,15 +443,15 @@ RexxObject *RexxList::insertRexx( - RexxObject *value, /* new value to add */ - RexxObject *index) /* addition insertion index */ + RexxObject *_value, /* new value to add */ + RexxObject *_index) /* addition insertion index */ /******************************************************************************/ /* Function: Publicly accessible version of the list insert function. */ /******************************************************************************/ { - required_arg(value, ONE); /* must have a value to insert */ + required_arg(_value, ONE); /* must have a value to insert */ /* go do the real insert */ - return this->insert(value, index); + return this->insert(_value, _index); } @@ -462,17 +462,17 @@ * * @return The index of the appended item. */ -RexxObject *RexxList::append(RexxObject *value) +RexxObject *RexxList::append(RexxObject *_value) { - required_arg(value, ONE); + required_arg(_value, ONE); // this is just an insertion operation with an ommitted index. - return insert(value, OREF_NULL); + return insert(_value, OREF_NULL); } RexxObject *RexxList::insert( - RexxObject *value, /* new value to add */ - RexxObject *index) /* addition insertion index */ + RexxObject *_value, /* new value to add */ + RexxObject *_index) /* addition insertion index */ /******************************************************************************/ /* Function: Add a new element to the list at the given insertion point. */ /* TheNilObject indicates it should be added to the list fron */ @@ -480,15 +480,15 @@ { LISTENTRY *element; /* list element */ LISTENTRY *new_element; /* new insertion element */ - long new_index; /* index of new inserted item */ + size_t new_index; /* index of new inserted item */ /* make sure we have room to insert */ new_index = this->getFree(); /* point to the actual element */ new_element = ENTRY_POINTER(new_index); - if (index == TheNilObject) /* inserting at the front? */ + if (_index == TheNilObject) /* inserting at the front? */ element = NULL; /* flag this as new */ - else if (index == OREF_NULL) { /* inserting at the end? */ + else if (_index == OREF_NULL) { /* inserting at the end? */ if (this->last == LIST_END) /* currently empty? */ element = NULL; /* just use the front insert code */ else /* insert after the last element */ @@ -496,14 +496,14 @@ } else { /* locate this entry */ - element = this->getEntry(index, (RexxObject *)IntegerOne); + element = this->getEntry(_index, (RexxObject *)IntegerOne); if (element == NULL) /* index doesn't exist? */ /* raise an error */ - report_exception1(Error_Incorrect_method_index, index); + report_exception1(Error_Incorrect_method_index, _index); } this->count++; /* increase our count */ /* set the value */ - OrefSet(this->table, new_element->value, value); + OrefSet(this->table, new_element->value, _value); if (element == NULL) { /* adding at the front */ if (this->last == LIST_END) { /* first element added? */ this->first = new_index; /* set this as the first */ @@ -539,13 +539,13 @@ } RexxObject *RexxList::remove( - RexxObject *index) /* index of item to remove */ + RexxObject *_index) /* index of item to remove */ /******************************************************************************/ /* Function: Remove a list item from the list */ /******************************************************************************/ { /* just remove the given index */ - return this->primitiveRemove(this->getEntry(index, (RexxObject *)IntegerOne)); + return this->primitiveRemove(this->getEntry(_index, (RexxObject *)IntegerOne)); } RexxObject *RexxList::primitiveRemove( @@ -554,25 +554,25 @@ /* Function: Remove a list item from the list */ /******************************************************************************/ { - RexxObject *value; /* value of the removed item */ - LISTENTRY *previous; /* previous entry */ - LISTENTRY *next; /* next entry */ + RexxObject *_value; /* value of the removed item */ + LISTENTRY *_previous; /* previous entry */ + LISTENTRY *_next; /* next entry */ if (element == NULL) /* not a valid index? */ return TheNilObject; /* just return .nil */ - value = element->value; /* copy the value */ + _value = element->value; /* copy the value */ if (element->next != LIST_END) { /* not end of the list? */ /* point to the next entry */ - next = ENTRY_POINTER(element->next); - next->previous = element->previous;/* update the previous pointer */ + _next = ENTRY_POINTER(element->next); + _next->previous = element->previous;/* update the previous pointer */ } else this->last = element->previous; /* need to update the last pointer */ if (element->previous != LIST_END) { /* not end of the list? */ /* point to the next entry */ - previous = ENTRY_POINTER(element->previous); - previous->next = element->next; /* remove this from the chain */ + _previous = ENTRY_POINTER(element->previous); + _previous->next = element->next; /* remove this from the chain */ } else this->first = element->next; /* need to update the last pointer */ @@ -582,7 +582,7 @@ element->next = this->free; /* new head of the free chain */ this->free = ENTRY_INDEX(element); /* this is the first free element */ - return value; /* return the old value */ + return _value; /* return the old value */ } RexxObject *RexxList::firstItem(void) @@ -634,17 +634,17 @@ } RexxObject *RexxList::next( - RexxObject *index) /* index of the target item */ + RexxObject *_index) /* index of the target item */ /******************************************************************************/ /* Function: Return the next item after the given indexed item */ /******************************************************************************/ { LISTENTRY *element; /* current working entry */ /* locate this entry */ - element = this->getEntry(index, (RexxObject *)IntegerOne); + element = this->getEntry(_index, (RexxObject *)IntegerOne); if (element == NULL) /* not a valid index? */ /* raise an error */ - report_exception1(Error_Incorrect_method_index, index); + report_exception1(Error_Incorrect_method_index, _index); if (element->next == LIST_END) /* no next item? */ return TheNilObject; /* just return .nil */ @@ -655,7 +655,7 @@ } RexxObject *RexxList::previous( - RexxObject *index) /* index of the target item */ + RexxObject *_index) /* index of the target item */ /******************************************************************************/ /* Function: Return the item previous to the indexed item */ /******************************************************************************/ @@ -663,10 +663,10 @@ LISTENTRY *element; /* current working entry */ /* locate this entry */ - element = this->getEntry(index, (RexxObject *)IntegerOne); + element = this->getEntry(_index, (RexxObject *)IntegerOne); if (element == NULL) /* not a valid index? */ /* raise an error */ - report_exception1(Error_Incorrect_method_index, index); + report_exception1(Error_Incorrect_method_index, _index); if (element->previous == LIST_END) /* no previous item? */ return TheNilObject; /* just return .nil */ @@ -676,7 +676,7 @@ } RexxObject *RexxList::hasIndex( - RexxObject *index) /* index of the target item */ + RexxObject *_index) /* index of the target item */ /******************************************************************************/ /* Function: Return an index existence flag */ /******************************************************************************/ @@ -684,7 +684,7 @@ LISTENTRY *element; /* current working entry */ /* locate this entry */ - element = this->getEntry(index, (RexxObject *)IntegerOne); + element = this->getEntry(_index, (RexxObject *)IntegerOne); /* return an existence flag */ return (element!= NULL) ? (RexxObject *)TheTrueObject : (RexxObject *)TheFalseObject; } @@ -720,12 +720,12 @@ { // just iterate through the list, copying the elements. RexxArray *array = (RexxArray *)new_array(this->count); - long next = this->first; - for (long i = 1; i <= this->count; i++) + size_t nextEntry = this->first; + for (size_t i = 1; i <= this->count; i++) { - LISTENTRY *element = ENTRY_POINTER(next); + LISTENTRY *element = ENTRY_POINTER(nextEntry); array->put(element->value, i); - next = element->next; + nextEntry = element->next; } return array; } @@ -738,8 +738,6 @@ */ RexxObject *RexxList::empty() { - // just iterate through the list, copying the elements. - RexxArray *array = (RexxArray *)new_array(this->count); while (this->first != LIST_END) { // get the list entry and remove the value @@ -775,12 +773,12 @@ // this requires protecting, since we're going to be creating new // integer objects. save(array); - long next = this->first; - for (long i = 1; i <= this->count; i++) + size_t nextEntry = this->first; + for (size_t i = 1; i <= this->count; i++) { - LISTENTRY *element = ENTRY_POINTER(next); - array->put((RexxObject *)new_integer(next), i); - next = element->next; + LISTENTRY *element = ENTRY_POINTER(nextEntry); + array->put((RexxObject *)new_integer(nextEntry), i); + nextEntry = element->next; } discard_hold(array); return array; @@ -801,16 +799,16 @@ required_arg(target, ONE); // ok, now run the list looking for the target item - long next = this->first; - for (long i = 1; i <= this->count; i++) + size_t nextEntry = this->first; + for (size_t i = 1; i <= this->count; i++) { - LISTENTRY *element = ENTRY_POINTER(next); + LISTENTRY *element = ENTRY_POINTER(nextEntry); // if we got a match, return the item if (target->equalValue(element->value)) { - return new_integer(next); + return new_integer(nextEntry); } - next = element->next; + nextEntry = element->next; } // no match return TheNilObject; @@ -831,16 +829,16 @@ required_arg(target, ONE); // ok, now run the list looking for the target item - long next = this->first; - for (long i = 1; i <= this->count; i++) + size_t nextEntry = this->first; + for (size_t i = 1; i <= this->count; i++) { - LISTENTRY *element = ENTRY_POINTER(next); + LISTENTRY *element = ENTRY_POINTER(nextEntry); // if we got a match, return the item if (target->equalValue(element->value)) { return TheTrueObject; } - next = element->next; + nextEntry = element->next; } // no match return TheFalseObject; @@ -860,17 +858,18 @@ required_arg(target, ONE); // ok, now run the list looking for the target item - long next = this->first; - for (long i = 1; i <= this->count; i++) + size_t nextEntry = this->first; + + for (size_t i = 1; i <= this->count; i++) { - LISTENTRY *element = ENTRY_POINTER(next); + LISTENTRY *element = ENTRY_POINTER(nextEntry); // if we got a match, return the item if (target->equalValue(element->value)) { // remove this item return primitiveRemove(element); } - next = element->next; + nextEntry = element->next; } // no match return TheNilObject; @@ -878,13 +877,13 @@ RexxObject *RexxList::indexOfValue( - RexxObject *value) + RexxObject *_value) /*****************************************************************************/ /* Function: Return the index for the value that was passed in */ /* or OREF_NULL */ /*****************************************************************************/ { - RexxObject *index = OREF_NULL; + RexxObject *_index = OREF_NULL; RexxObject *last_index; RexxObject *this_value = OREF_NULL; /* get the last index in the list */ @@ -893,13 +892,13 @@ if (last_index != TheNilObject) /* loop thru the list looking for the */ /* specified value */ - for (index = this->firstRexx(); - ((this_value = this->value(index)) != value) && index != last_index; - index = this->next(index)); + for (_index = this->firstRexx(); + ((this_value = this->value(_index)) != _value) && _index != last_index; + _index = this->next(_index)); /* return the index if the value was */ /* in the list */ - if (this_value == value) - return index; + if (this_value == _value) + return _index; /* otherwise return nothing */ return OREF_NULL; } @@ -911,18 +910,18 @@ { RexxArray *array; /* returned array value */ LIST... [truncated message content] |