void RexxEnvelope::addTable( RexxObject *obj) /* table object to rehash */ /******************************************************************************/ /* Function: Add an object to the rehash table for later processing */ /******************************************************************************/ { /* the following table will be used */ /* by the table_unflatten method. */ /* */ /* Every table that gets unflattened */ /* place itself in this table. Once */ /* every object has been unflattened */ /* we traverse this table and allow */ /* the hashtables to re-hash their */ /* since some hash value may have */ /* change */ if (this->rehashtable == OREF_NULL) /* first table added? */ { /* create the table now */ OrefSet(this, this->rehashtable, new_identity_table()); } /* use put to make sure we only get */ /* a single version of each table */ this->rehashtable->put(TheNilObject, obj); }
/** * Initialize an interpreter instance. * * @param activity The root activity for the interpreter instance. * @param handlers The exit handlers used by all threads running under this instance. * @param defaultEnvironment * The default address environment for this interpreter instance. Each * active interpreter instance can define its own default environment. */ void InterpreterInstance::initialize(RexxActivity *activity, RexxOption *options) { rootActivity = activity; allActivities = new_list(); searchExtensions = new_list(); // this will be filled in during options processing requiresFiles = new_directory(); // our list of loaded requires packages // this gets added to the entire active list. allActivities->append((RexxObject *)activity); globalReferences = new_identity_table(); // create a default wrapper for this security manager securityManager = new SecurityManager(OREF_NULL); // set the default system address environment (can be overridden by options) defaultEnvironment = SystemInterpreter::getDefaultAddressName(); // our list of command handlers (must be done before options are processed) commandHandlers = new_directory(); // associate the thread with this instance activity->setupAttachedActivity(this); // create a local environment localEnvironment = new_directory(); processOptions(options); // when handled originally, we didn't have the exits setup // do this now. activity->setupExits(); // do system specific initialization sysInstance.initialize(this, options); // register the system command handlers for this platform. sysInstance.registerCommandHandlers(this); // now do the local initialization; Interpreter::initLocal(); }
/** * Request that an activity be informed of any variable * modifications. * * @param informee The requesting activity. */ void RexxVariable::inform(Activity *informee) { // we don't typically have a dependents list until the // first time this is needed if (dependents == OREF_NULL) { // use an object table for this setField(dependents, new_identity_table()); } // add this to the table as the index dependents->put(TheNilObject, informee); }
void RexxVariable::inform( RexxActivity *informee) /* activity to inform of changes */ /****************************************************************************/ /* Function: Set up an activity notification for a variable change */ /****************************************************************************/ { if (this->dependents == OREF_NULL) /* no dependents yet? */ { /* set this up as an object table */ OrefSet(this, this->dependents, new_identity_table()); } /* add this to the table */ this->dependents->put(TheNilObject, (RexxObject *)informee); }
RexxObject *RexxBehaviour::addScope( RexxObject *scope) /* new scope for the scope table */ /******************************************************************************/ /* Function: Set a new set of scoping information for an object */ /******************************************************************************/ { if (this->scopes == OREF_NULL) /* no scopes set? */ { /* add a scope table to add to */ OrefSet(this, this->scopes, new_identity_table()); } /* set the scoping info */ this->scopes->add(scope, TheNilObject); /* add the scope list for this scope */ this->scopes->add(this->scopes->allAt(TheNilObject), scope); return OREF_NULL; /* return the big nothing */ }
RexxBuffer *RexxEnvelope::pack( 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 */ 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_identity_table()); OrefSet(this, this->duptable, new_identity_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. duptable->contents->setHasNoReferences(); OrefSet(this, this->buffer, new RexxSmartBuffer(DEFAULT_ENVELOPE_BUFFER)); // 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. // 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(TheObjectClass->newObject()); // we start the flattening process with the received object firstObject = this->receiver; 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); // ok, keep flattening until will find our marker object on the stack newSelf->flatten(this); /* start the flatten process. */ 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 */ // now unwrap the smart buffer and fix the length of the real buffer // behind it to the size we've written to it. RexxBuffer *letter = buffer->getBuffer(); letter->setDataLength(buffer->getDataLength()); return letter; }