/** * Resolve the "stem.[a,b,c]=" to the equivalent stem.a.b.c= form, * with all of the indices taken as constants * * @param tailElements * The array of arguments. the first argument is the * assigned value. All additional arguments are the * tail pieces. * @param argCount The count of arguments. * * @return Returns nothing. */ RexxObject *StemClass::bracketEqual(RexxObject **tailElements, size_t argCount) { // no value to set? This is an error if (argCount == 0) { reportException(Error_Incorrect_method_noarg, IntegerOne); } RexxObject *newValue = requiredArgument(tailElements[0], ARG_ONE); // if the argument count is 1, we're just setting the default value if (argCount == 1) { // stem value as default? don't allow this as it leads to recursion loops if (isStem(newValue)) { reportException(Error_Execution_nostem); } setField(value, newValue); // this clears out all of our elements and gets marked as having an // explicit value. tails.clear(); dropped = false; return OREF_NULL; } // create a searchable tail from the array elements // and set the variable value CompoundVariableTail resolved_tail((RexxInternalObject **)(tailElements + 1), argCount - 1); CompoundTableElement *variable = getCompoundVariable(resolved_tail); variable->set(newValue); return OREF_NULL; }
/** * Remove an item from the collection. This is essentially * equivalent to a drop operation on the stem variable. * * @param tails The set of tail indexes. * @param argCount The number of indexes. * * @return The removed object. If nothing was removed, this returns * .nil. */ RexxInternalObject *StemClass::remove(RexxObject **tailElements, size_t argCount) { // if asked to remove the default value, reset this back to the name if (argCount == 0) { // replace with the name and return the old value. RexxInternalObject *oldValue = value; setField(value, getName()); return oldValue; } // compose the tail element CompoundVariableTail resolved_tail((RexxInternalObject **)tailElements, argCount); CompoundTableElement *compound = findCompoundVariable(resolved_tail); // if there's a variable there, and it has a real value, then // we have something to remove if (compound != OREF_NULL && compound->getVariableValue() != OREF_NULL) { // get the value, which is the return value, and drop the variable. RexxInternalObject *oldValue = compound->getVariableValue(); compound->drop(); return oldValue; } return TheNilObject; // nothing dropped. }
/** * Perform a lookup on a stem object. * * @param tailElements * The array of tail elements used to construct * the tail. All tail elements are constants at * this point. * @param argCount The count of tail arguments. * * @return The compound variable lookup value. */ RexxInternalObject *StemClass::bracket(RexxObject **tailElements, size_t argCount) { // no arguments just returns the default value if (argCount == 0) { return value; } // create a searchable tail, and perform the lookup CompoundVariableTail resolved_tail((RexxInternalObject **)tailElements, argCount); return evaluateCompoundVariableValue(OREF_NULL, stemName, resolved_tail); }
/** * Test if this compound variable has a given index. * * @param tails The set of tail expressions. * @param argCount The argument count * * @return True if the fully resolved tail exists in the stem, false * otherwise. */ RexxObject *StemClass::hasIndex(RexxObject **tailElements, size_t argCount) { if (argCount == 0) { return TheTrueObject; // we always have something here } // compose the tail element CompoundVariableTail resolved_tail((RexxInternalObject **)tailElements, argCount); // see if we have a compound CompoundTableElement *compound = findCompoundVariable(resolved_tail); // if there's a variable there, and it has a real value, then // this is true. return booleanObject(compound != OREF_NULL && compound->getVariableValue() != OREF_NULL); }
RexxCompoundElement *RexxCompoundTable::findEntry(RexxString *tail, bool create) { /* process the tail and search */ RexxCompoundTail resolved_tail(tail); return findEntry(&resolved_tail, create); }
/** * Drop an array element for an API class. * * @param tail The direct tail value. */ void StemClass::dropElement(const char *tail) { CompoundVariableTail resolved_tail(tail); dropElement(resolved_tail); }
/** * Drop an array element for an API class. * * @param tail The direct tail value. */ void StemClass::dropElement(size_t tail) { CompoundVariableTail resolved_tail(tail); dropElement(resolved_tail); }
/** * Evaluate an array element for an API class. * * @param tail The direct tail value. * * @return The object value. If the stem element does not exist or * has been dropped, this returns OREF_NULL. */ RexxObject *StemClass::getElement(const char *tail) { CompoundVariableTail resolved_tail(tail); return getElement(resolved_tail); }
/** * Set a single stem variable object using a simple string * value tail as a result of an api call. * * @param tail The index of the target value. * @param value The new value to assign. */ void StemClass::setElement(size_t tail, RexxObject *newValue) { CompoundVariableTail resolved_tail(tail); RexxVariable *variable = getCompoundVariable(resolved_tail); variable->set(newValue); }