/** * Add a handler for a registered subcom handler to the * address handler list. * * @param name The environment name of the handler. * @param registeredName * The name of the registered subcom handler. */ void InterpreterInstance::addCommandHandler(const char *name, const char *registeredName) { RexxString *handlerName = new_upper_string(name); CommandHandler *handler = new CommandHandler(registeredName); // it's possible we were give a bogus name, so validate this first if (handler->isResolved()) { commandHandlers->put((RexxObject *)handler, handlerName); } }
RexxClassObject RexxEntry FindContextClass(RexxMethodContext *c, CSTRING n) { ApiContext context(c); try { // convert the name to a string instance, and check the environments. RexxString *name = new_upper_string(n); return (RexxClassObject)context.ret(context.context->findClass(name)); } catch (NativeActivation *) { } return NULLOBJECT; }
RexxObjectPtr RexxEntry ForwardMessage(RexxMethodContext *c, RexxObjectPtr o, CSTRING n, RexxClassObject clazz, RexxArrayObject a) { ApiContext context(c); try { RexxString *message = n == NULL ? OREF_NULL : new_upper_string(n); ProtectedObject result(context.activity); context.context->forwardMessage((RexxObject *)o, message, (RexxClass *)clazz, (ArrayClass *)a, result); return context.ret((RexxObject *)result); } catch (NativeActivation *) { } return NULLOBJECT; }
/** * Load all of the routines in a package, registering them with * the package manager. * * @param table The package table describing this package. */ void LibraryPackage::loadRoutines(RexxRoutineEntry *table) { // no routines exported by this package? Just return without // doing anything. if (table == NULL) { return; } // create a directory of loaded routines setField(routines, new_string_table()); // and a version using an uppercase name map setField(publicRoutines, new_string_table()); while (table->style != 0) { // table names tend to be specified in friendly form, we need to // convert them to uppercase because "normal" Rexx function names // tend to be uppercase. Protected<RexxString> target = new_upper_string(table->name); Protected<RexxString> routineName = new_string(table->name); Protected<BaseNativeRoutine> func; if (table->style == ROUTINE_CLASSIC_STYLE) { func = new RegisteredRoutine(libraryName, routineName, (RexxRoutineHandler *)table->entryPoint); } else { func = new NativeRoutine(libraryName, routineName, (PNATIVEROUTINE)table->entryPoint); } Protected<RoutineClass> routine = new RoutineClass(routineName, func); // add this to our local table. Our local table needs to keep the original case, // since those will be referenced by ::ROUTINE statements. routines->put(routine, routineName); // and also keep an upper case version for merging with packages publicRoutines->put(routine, target); // add this to the global function pool PackageManager::addPackageRoutine(target, routine); // step to the next table entry table++; } }
/** * Add a handler to the environment list. * * @param name The name of the address environment this services. * @param entryPoint The entry point address of the handler. */ void InterpreterInstance::addCommandHandler(const char *name, REXXPFN entryPoint) { RexxString *handlerName = new_upper_string(name); commandHandlers->put((RexxObject *)new CommandHandler(entryPoint), handlerName); }
inline RexxString *new_upper_string(const char *string) { return new_upper_string(string, strlen(string), -1); }