CPPCode.cpp

Go to the documentation of this file.

/*----------------------------------------------------------------------------*/
/*                                                                            */
/* Copyright (c) 1995, 2004 IBM Corporation. All rights reserved.             */
/* Copyright (c) 2005-2009 Rexx Language Association. All rights reserved.    */
/*                                                                            */
/* This program and the accompanying materials are made available under       */
/* the terms of the Common Public License v1.0 which accompanies this         */
/* distribution. A copy is also available at the following address:           */
/* http://www.oorexx.org/license.html                          */
/*                                                                            */
/* Redistribution and use in source and binary forms, with or                 */
/* without modification, are permitted provided that the following            */
/* conditions are met:                                                        */
/*                                                                            */
/* Redistributions of source code must retain the above copyright             */
/* notice, this list of conditions and the following disclaimer.              */
/* Redistributions in binary form must reproduce the above copyright          */
/* notice, this list of conditions and the following disclaimer in            */
/* the documentation and/or other materials provided with the distribution.   */
/*                                                                            */
/* Neither the name of Rexx Language Association nor the names                */
/* of its contributors may be used to endorse or promote products             */
/* derived from this software without specific prior written permission.      */
/*                                                                            */
/* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS        */
/* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT          */
/* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS          */
/* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT   */
/* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,      */
/* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED   */
/* TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,        */
/* OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY     */
/* OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING    */
/* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS         */
/* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.               */
/*                                                                            */
/*----------------------------------------------------------------------------*/
 
#include "RexxCore.h"
#include "CPPCode.hpp"
#include "ActivityManager.hpp"
#include "ProtectedObject.hpp"
#include "Interpreter.hpp"
#include "RexxVariableDictionary.hpp"
#include "ActivationFrame.hpp"
#include "SourceFile.hpp"
 
 
/**
 * Allocate a new CPP code object.
 *
 * @param size   the allocation size.
 *
 * @return A pointer to the newly allocated object.
 */
void *CPPCode::operator new(size_t size)
{
    // just allocate ane return
    return new_object(size, T_CPPCode);
}
 
 
/**
 * Constructor for a CPPCode object.
 *
 * @param index    The index of the method used to restore unflattened internal method.
 * @param entry    The entry point address.
 * @param argcount The number of arguments this method expects.
 * @param passNamedArgs True if the named arguments must be passed.
 */
CPPCode::CPPCode(size_t index, PCPPM entry, size_t argcount, bool passNamedArgs)
{
    methodIndex = (uint16_t)index;
    cppEntry = entry;
    argumentCount = (uint16_t)argcount;
    passNamedArguments = passNamedArgs;
}
 
 
void CPPCode::liveGeneral(int reason)
/******************************************************************************/
/* Function:  Generalized object marking                                      */
/******************************************************************************/
{
    // Inspired by ooRexx5, but the approach is different...
    // Instead of assigning package = TheRexxPackage when reason == PREPARINGIMAGE (unsupported by ooRexx4)
    // I mark the CPPCode instance as belonging to the RexxPackage, and will return TheRexxPackage when asking its package.
    if (reason == SAVINGIMAGE) this->setInRexxPackage();
 
    if (reason == RESTORINGIMAGE)        /* restoring the image?              */
    {
        this->cppEntry = exportedMethods[this->methodIndex];
    }
}
 
 
RexxObject *CPPCode::unflatten(RexxEnvelope *envelope)
/******************************************************************************/
/* Function:  unflatten an object                                             */
/******************************************************************************/
{
    this->cppEntry = exportedMethods[this->methodIndex];
    return (RexxObject *)this;
}
 
 
/**
 * Run (or call) a CPPMethod.
 *
 * @param activity The activity we're running under.
 * @param method   The method to run.
 * @param receiver The receiver object.
 * @param messageName
 *                 The name used to invoke the message.
 * @param argPtr   The actual arguments.
 * @param count    The argument count.
 * @param result   The returned result.
 */
void CPPCode::run(RexxActivity *activity, RexxMethod *method, RexxObject *receiver, RexxString *messageName,
    RexxObject **argPtr, size_t count, size_t named_count, ProtectedObject &result)
{
    InternalActivationFrame frame(activity, messageName, receiver, method, argPtr, count, named_count);
    PCPPM methodEntry = this->cppEntry;  /* get the entry point               */
                                       /* expecting an array?               */
                                       /* expecting a pointer/count pair?   */
    if (this->argumentCount == A_COUNT)
    {
      // Here, named arguments are automatically supported
                                       /* we can pass this right on         */
      result = (receiver->*((PCPPMC1)methodEntry))(argPtr, count, named_count);
    }
    else
    {
        if (count > argumentCount)
        {
            reportException(Error_Incorrect_method_maxarg, OREF_positional, this->argumentCount);
        }
 
        // JLF: example with UNKNOWN method
        // RexxObject::processUnknown : put all the positional arguments in the 2nd arg, put all the named arguments in the named argument NAMEDARGUMENT
        //     calls RexxMethod::run : forward the 2 positional args + 1 named arg to the code object
        //         calls CPPCode::run : call a CPP method by passing the positional & named args as C++ parameters,
        //             calls RexxObject::unknownRexx : forward to the virtual function (message, arguments, namedArguments)
        //                 calls RexxInteger::unknown : just reissue to the string value (message, arguments, namedArguments)
        //                     calls RexxObject::sendMessage(RexxString *message, RexxArray *args, RexxDirectory *namedArgs)
        //                         calls RexxObject::sendMessage(RexxString *message, RexxArray  *arguments, ProtectedObject &result
        //                         Now we are back to the standard way to pass arguments:
        //                             passing arguments->data(), arguments->size()
        //                             where the named arguments are after the positional arguments.
 
        // Get the start of the named arguments now, because argPtr may be assigned to the temporary list argument_list.
        // For the moment, the named arguments are passed as a pointer + count
        // Declaration on callee side:
        // If one positional arg:  (RexxObject *positional1, RexxObject **named_arglist, size_t named_argcount)
        // If two positional args: (RexxObject *positional1, RexxObject *positional2, RexxObject **named_arglist, size_t named_argcount)
        // etc. up to 7 positional arguments.
        RexxObject **named_argPtr = argPtr + count;
 
        // JLF: I don't understand why this temporary list is needed...
        // ah, yes: it's to pass NULL for the omitted parameters at the end.
        // Not needed when count == argumentCount, because here no omitted paramaters.
 
        // This is the temporary list of positional arguments
        RexxObject * argument_list[7];
        if (count < argumentCount)              /* need to pad these out?            */
        {
            // null out the argument list
            memset(argument_list, 0, sizeof(argument_list));
            // and copy over the provided argument pointers
            memcpy(argument_list, argPtr, count * sizeof(RexxObject *));
            // now switch the argument pointer to the temporary
            argPtr = &argument_list[0];
        }
 
        // now we make the actual call
 
        if (passNamedArguments == false)  // if no need to pass named arguments
        {
            switch (argumentCount)
            {
              case 0:                        /* zero                              */
                result = (receiver->*((PCPPM0)methodEntry))();
                break;
 
              case 1:
                result = (receiver->*((PCPPM1)methodEntry))(argPtr[0]);
                break;
 
              case 2:
                result = (receiver->*((PCPPM2)methodEntry))(argPtr[0], argPtr[1]);
                break;
 
              case 3:
                result = (receiver->*((PCPPM3)methodEntry))(argPtr[0], argPtr[1], argPtr[2]);
                break;
 
              case 4:
                result = (receiver->*((PCPPM4)methodEntry))(argPtr[0], argPtr[1], argPtr[2], argPtr[3]);
                break;
 
              case 5:
                result = (receiver->*((PCPPM5)methodEntry))(argPtr[0], argPtr[1], argPtr[2], argPtr[3], argPtr[4]);
                break;
 
              case 6:
                result = (receiver->*((PCPPM6)methodEntry))(argPtr[0], argPtr[1], argPtr[2], argPtr[3], argPtr[4], argPtr[5]);
                break;
 
              case 7:
                result = (receiver->*((PCPPM7)methodEntry))(argPtr[0], argPtr[1], argPtr[2], argPtr[3], argPtr[4], argPtr[5], argPtr[6]);
                break;
            }
        }
        else
        {
            switch (argumentCount)
            {
              case 0:                        /* zero                              */
                result = (receiver->*((PCPPM0N)methodEntry))(named_argPtr, named_count);
                break;
 
              case 1:
                result = (receiver->*((PCPPM1N)methodEntry))(argPtr[0],
                                                            named_argPtr, named_count);
                break;
 
              case 2:
                result = (receiver->*((PCPPM2N)methodEntry))(argPtr[0], argPtr[1],
                                                            named_argPtr, named_count);
                break;
 
              case 3:
                result = (receiver->*((PCPPM3N)methodEntry))(argPtr[0], argPtr[1], argPtr[2],
                                                            named_argPtr, named_count);
                break;
 
              case 4:
                result = (receiver->*((PCPPM4N)methodEntry))(argPtr[0], argPtr[1], argPtr[2], argPtr[3],
                                                            named_argPtr, named_count);
                break;
 
              case 5:
                result = (receiver->*((PCPPM5N)methodEntry))(argPtr[0], argPtr[1], argPtr[2], argPtr[3], argPtr[4],
                                                            named_argPtr, named_count);
                break;
 
              case 6:
                result = (receiver->*((PCPPM6N)methodEntry))(argPtr[0], argPtr[1], argPtr[2], argPtr[3], argPtr[4], argPtr[5],
                                                            named_argPtr, named_count);
                break;
 
              case 7:
                result = (receiver->*((PCPPM7N)methodEntry))(argPtr[0], argPtr[1], argPtr[2], argPtr[3], argPtr[4], argPtr[5], argPtr[6],
                                                            named_argPtr, named_count);
                break;
            }
        }
    }
}
 
 
/**
 * Allocate a new attribute getter code object.
 *
 * @param size   the allocation size.
 *
 * @return A pointer to the newly allocated object.
 */
void *AttributeGetterCode::operator new(size_t size)
{
    // just allocate ane return
    return new_object(size, T_AttributeGetterCode);
}
 
void AttributeGetterCode::live(size_t liveMark)
/******************************************************************************/
/* Function:  Normal garbage collection live marking                          */
/******************************************************************************/
{
  memory_mark(this->attribute);
  memory_mark(this->source);
}
 
void AttributeGetterCode::liveGeneral(int reason)
/******************************************************************************/
/* Function:  Generalized object marking                                      */
/******************************************************************************/
{
    // Inspired by ooRexx5, but the approach is different...
    // Instead of assigning package = TheRexxPackage when reason == PREPARINGIMAGE (unsupported by ooRexx4)
    // I mark the AttributeGetterCode instance as belonging to the RexxPackage, and will return TheRexxPackage when asking its package.
    if (reason == SAVINGIMAGE) this->setInRexxPackage();
 
    memory_mark_general(this->attribute);
    memory_mark_general(this->source);
}
 
void AttributeGetterCode::flatten(RexxEnvelope *envelope)
/******************************************************************************/
/* Function:  Flatten an object                                               */
/******************************************************************************/
{
  setUpFlatten(AttributeGetterCode)
 
  flatten_reference(newThis->attribute, envelope);
  flatten_reference(newThis->source, envelope);
 
  cleanUpFlatten
}
 
 
/**
 * Execute an attribute-get operation.
 *
 * @param activity The current activity.
 * @param method   The method we're invoking.
 * @param receiver The receiver object.
 * @param messageName
 *                 The name of the message used to invoke the method.
 * @param argPtr   The pointer to the arguments.
 * @param count    The argument count.
 * @param result   The returned result.
 */
void AttributeGetterCode::run(RexxActivity *activity, RexxMethod *method, RexxObject *receiver, RexxString *messageName,
    RexxObject **argPtr, size_t count, size_t named_count, ProtectedObject &result)
{
    // validate the number of arguments
    if (count > 0)
    {
        reportException(Error_Incorrect_method_maxarg, OREF_positional, (wholenumber_t)0);
    }
    // this is simplier if the method is not guarded
    if (!method->isGuarded())
    {
        result = attribute->getValue(receiver->getObjectVariables(method->getScope()));
    }
    else {
        // get the variable pool and get the guard lock
        RexxVariableDictionary *objectVariables = receiver->getObjectVariables(method->getScope());
        objectVariables->reserve(activity);
        result = attribute->getValue(objectVariables);
        // and ensure we release this afterwards
        objectVariables->release(activity);
    }
}
 
 
/**
 * Allocate a new attribute setter code object.
 *
 * @param size   the allocation size.
 *
 * @return A pointer to the newly allocated object.
 */
void *AttributeSetterCode::operator new(size_t size)
{
    // just allocate ane return
    return new_object(size, T_AttributeSetterCode);
}
 
 
/**
 * Execute an attribute-set operation.
 *
 * @param activity The current activity.
 * @param method   The method we're invoking.
 * @param receiver The receiver object.
 * @param messageName
 *                 The name of the message used to invoke the method.
 * @param argPtr   The pointer to the arguments.
 * @param count    The argument count.
 * @param result   The returned result.
 */
void AttributeSetterCode::run(RexxActivity *activity, RexxMethod *method, RexxObject *receiver, RexxString *messageName,
    RexxObject **argPtr, size_t count, size_t named_count, ProtectedObject &result)
{
    // validate the number of arguments
    if (count > 1)
    {
        reportException(Error_Incorrect_method_maxarg, OREF_positional, 1);
    }
 
    if (count == 0 || *argPtr == OREF_NULL)
    {
        missingArgument(OREF_positional, 1);
    }
    // this is simplier if the method is not guarded
    if (!method->isGuarded())
    {
        // go set the attribue
        attribute->set(receiver->getObjectVariables(method->getScope()), argPtr[0]);
    }
    else {
        // get the variable pool and get the guard lock
        RexxVariableDictionary *objectVariables = receiver->getObjectVariables(method->getScope());
        objectVariables->reserve(activity);
        // go set the attribue
        attribute->set(objectVariables, argPtr[0]);
        // and ensure we release this afterwards
        objectVariables->release(activity);
    }
}
 
 
/**
 * Allocate a new constant getter code object.
 *
 * @param size   the allocation size.
 *
 * @return A pointer to the newly allocated object.
 */
void *ConstantGetterCode::operator new(size_t size)
{
    // just allocate ane return
    return new_object(size, T_AttributeGetterCode);
}
 
 
void ConstantGetterCode::live(size_t liveMark)
/******************************************************************************/
/* Function:  Normal garbage collection live marking                          */
/******************************************************************************/
{
  memory_mark(this->constantValue);
  memory_mark(this->source);
}
 
void ConstantGetterCode::liveGeneral(int reason)
/******************************************************************************/
/* Function:  Generalized object marking                                      */
/******************************************************************************/
{
    // Inspired by ooRexx5, but the approach is different...
    // Instead of assigning package = TheRexxPackage when reason == PREPARINGIMAGE (unsupported by ooRexx4)
    // I mark the ConstantGetterCode instance as belonging to the RexxPackage, and will return TheRexxPackage when asking its package.
    if (reason == SAVINGIMAGE) this->setInRexxPackage();
 
    memory_mark_general(this->constantValue);
    memory_mark_general(this->source);
}
 
void ConstantGetterCode::flatten(RexxEnvelope *envelope)
/******************************************************************************/
/* Function:  Flatten an object                                               */
/******************************************************************************/
{
  setUpFlatten(ConstantGetterCode)
 
  flatten_reference(newThis->constantValue, envelope);
  flatten_reference(newThis->source, envelope);
 
  cleanUpFlatten
}
 
 
/**
 * Execute a constant get operation
 *
 * @param activity The current activity.
 * @param method   The method we're invoking.
 * @param receiver The receiver object.
 * @param messageName
 *                 The name of the message used to invoke the method.
 * @param argPtr   The pointer to the arguments.
 * @param count    The argument count.
 * @param result   The returned result.
 */
void ConstantGetterCode::run(RexxActivity *activity, RexxMethod *method, RexxObject *receiver, RexxString *messageName,
    RexxObject **argPtr, size_t count, size_t named_count, ProtectedObject &result)
{
    // validate the number of arguments
    if (count > 0)
    {
        reportException(Error_Incorrect_method_maxarg, OREF_positional, (wholenumber_t)0);
    }
    result = constantValue;
}
 
 
/**
 * Allocate a new abstract code object.
 *
 * @param size   the allocation size.
 *
 * @return A pointer to the newly allocated object.
 */
void *AbstractCode::operator new(size_t size)
{
    // just allocate ane return
    return new_object(size, T_AbstractCode);
}
 
void AbstractCode::live(size_t liveMark)
/******************************************************************************/
/* Function:  Normal garbage collection live marking                          */
/******************************************************************************/
{
  memory_mark(this->source);
}
 
void AbstractCode::liveGeneral(int reason)
/******************************************************************************/
/* Function:  Generalized object marking                                      */
/******************************************************************************/
{
    // Inspired by ooRexx5, but the approach is different...
    // Instead of assigning package = TheRexxPackage when reason == PREPARINGIMAGE (unsupported by ooRexx4)
    // I mark the AbstractCode instance as belonging to the RexxPackage, and will return TheRexxPackage when asking its package.
    if (reason == SAVINGIMAGE) this->setInRexxPackage();
 
    memory_mark_general(this->source);
}
 
void AbstractCode::flatten(RexxEnvelope *envelope)
/******************************************************************************/
/* Function:  Flatten an object                                               */
/******************************************************************************/
{
  setUpFlatten(AbstractCode)
 
  flatten_reference(newThis->source, envelope);
 
  cleanUpFlatten
}
 
 
/**
 * Execute a constant get operation
 *
 * @param activity The current activity.
 * @param method   The method we're invoking.
 * @param receiver The receiver object.
 * @param messageName
 *                 The name of the message used to invoke the method.
 * @param argPtr   The pointer to the arguments.
 * @param count    The argument count.
 * @param result   The returned result.
 */
void AbstractCode::run(RexxActivity *activity, RexxMethod *method, RexxObject *receiver, RexxString *messageName,
    RexxObject **argPtr, size_t count, size_t named_count, ProtectedObject &result)
{
    reportException(Error_Incorrect_method_abstract, messageName);
}
 
 
#include "RexxCore.h"
#include "TableClass.hpp"
#include "RexxMemory.hpp"
#include "RexxBehaviour.hpp"
#include "ClassClass.hpp"
#include "NumberStringClass.hpp"
#include "IntegerClass.hpp"
#include "StringClass.hpp"
#include "MutableBufferClass.hpp"
#include "ArrayClass.hpp"
#include "DirectoryClass.hpp"
#include "RelationClass.hpp"
#include "ListClass.hpp"
#include "QueueClass.hpp"
#include "SupplierClass.hpp"
#include "MethodClass.hpp"
#include "RoutineClass.hpp"
#include "PackageClass.hpp"
#include "RexxEnvelope.hpp"
#include "MessageClass.hpp"
#include "StemClass.hpp"
#include "RexxMisc.hpp"
#include "RexxNativeCode.hpp"
#include "RexxActivity.hpp"
#include "ActivityManager.hpp"
#include "RexxNativeActivation.hpp"
#include "RexxVariableDictionary.hpp"
#include "ExpressionVariable.hpp"
#include "RexxLocalVariables.hpp"
#include "ProtectedObject.hpp"
#include "PointerClass.hpp"
#include "BufferClass.hpp"
#include "WeakReferenceClass.hpp"
#include "ContextClass.hpp"
#include "StackFrameClass.hpp"
#include "BlockClass.hpp"
#include "TextClass.hpp"
 
PCPPM CPPCode::exportedMethods[] =     /* start of exported methods table   */
{
CPPM(RexxObject::objectName),
CPPM(RexxObject::objectNameEquals),
CPPM(RexxObject::run),
CPPM(RexxObject::stringRexx),
CPPM(RexxObject::notEqual),
CPPM(RexxObject::setMethod),
CPPM(RexxObject::hasMethodRexx),
CPPM(RexxObject::start),
CPPM(RexxObject::startWith),
CPPM(RexxObject::send),
CPPM(RexxObject::sendWith),
CPPM(RexxObject::unsetMethod),
CPPM(RexxObject::requestRexx),
CPPM(RexxObject::makeStringRexx),
CPPM(RexxObject::makeArrayRexx),
CPPM(RexxInternalObject::hasUninit),
CPPM(RexxObject::classObject),
CPPM(RexxObject::equal),
CPPM(RexxObject::strictEqual),
CPPM(RexxObject::hashCode),
CPPM(RexxObject::init),
CPPM(RexxObject::strictNotEqual),
CPPM(RexxObject::copyRexx),
CPPM(RexxObject::defaultNameRexx),
CPPM(RexxObject::unknownRexx),
CPPM(RexxObject::isInstanceOfRexx),
CPPM(RexxObject::isNilRexx),
CPPM(RexxObject::instanceMethodRexx),
CPPM(RexxObject::instanceMethodsRexx),
CPPM(RexxObject::dynamicTargetRexx),
CPPM(RexxObject::identityHashRexx),
CPPM(RexxObject::concatRexx),
CPPM(RexxObject::concatBlank),
 
CPPM(RexxObject::newRexx),
 
CPPM(RexxClass::setRexxDefined),       /* Class methods                     */
CPPM(RexxClass::defaultNameRexx),
CPPM(RexxClass::queryMixinClass),
CPPM(RexxClass::isMetaClassRexx), // ooRexx5
CPPM(RexxClass::isAbstractRexx), // ooRexx5
CPPM(RexxClass::getId),
CPPM(RexxClass::getBaseClass),
CPPM(RexxClass::getMetaClass),
CPPM(RexxClass::getSuperClasses),
CPPM(RexxClass::getSuperClass),
CPPM(RexxClass::getSubClasses),
CPPM(RexxClass::defmeths),
CPPM(RexxClass::defineMethod),
CPPM(RexxClass::defineMethods),
CPPM(RexxClass::defineClassMethod),
CPPM(RexxClass::removeClassMethod),
CPPM(RexxClass::deleteMethod),
CPPM(RexxClass::method),
CPPM(RexxClass::methods),
CPPM(RexxClass::inherit),
CPPM(RexxClass::uninherit),
CPPM(RexxClass::enhanced),
CPPM(RexxClass::mixinClassRexx),
CPPM(RexxClass::subclassRexx),
CPPM(RexxClass::equal),
CPPM(RexxClass::strictEqual),
CPPM(RexxClass::notEqual),
CPPM(RexxClass::isSubclassOf),
CPPM(RexxClass::getPackage),
 
CPPM(RexxClass::newRexx),
 
CPPM(RexxArray::sizeRexx),             /* Array methods                     */
CPPM(RexxArray::itemsRexx),
CPPM(RexxArray::dimension),
CPPM(RexxArray::getDimensions),
CPPM(RexxArray::supplier),
CPPM(RexxArray::getRexx),
CPPM(RexxArray::putRexx),
CPPM(RexxArray::hasIndexRexx),
CPPM(RexxArray::sectionRexx),
CPPM(RexxArray::removeRexx),
CPPM(RexxArray::firstRexx),
CPPM(RexxArray::firstItem),
CPPM(RexxArray::lastRexx),
CPPM(RexxArray::lastItem),
CPPM(RexxArray::nextRexx),
CPPM(RexxArray::previousRexx),
CPPM(RexxArray::appendRexx),
CPPM(RexxArray::allIndexes),
CPPM(RexxArray::allItems),
CPPM(RexxArray::empty),
CPPM(RexxArray::isEmpty),
CPPM(RexxArray::index),
CPPM(RexxArray::hasItem),
CPPM(RexxArray::removeItem),
CPPM(RexxArray::toString),
CPPM(RexxArray::stableSortRexx),
CPPM(RexxArray::stableSortWithRexx),
CPPM(RexxArray::insertRexx),
CPPM(RexxArray::deleteRexx),
CPPM(RexxArray::fill),
 
CPPM(RexxArray::newRexx),
CPPM(RexxArray::makeString),
CPPM(RexxArray::of),
 
CPPM(RexxDirectory::atRexx),           /* Directory methods                 */
CPPM(RexxDirectory::put),
CPPM(RexxDirectory::entryRexx),
CPPM(RexxDirectory::hasEntry),
CPPM(RexxDirectory::hasIndex),
CPPM(RexxDirectory::itemsRexx),
CPPM(RexxHashTableCollection::merge),
CPPM(RexxDirectory::removeRexx),
CPPM(RexxDirectory::setEntry),
CPPM(RexxDirectory::setMethod),
CPPM(RexxDirectory::supplier),
CPPM(RexxDirectory::allIndexes),
CPPM(RexxDirectory::allItems),
CPPM(RexxDirectory::empty),
CPPM(RexxDirectory::isEmpty),
CPPM(RexxDirectory::indexRexx),
CPPM(RexxDirectory::hasItem),
CPPM(RexxDirectory::removeItem),
 
CPPM(RexxDirectory::newRexx),
 
CPPM(RexxInteger::plus),               /* Integer methods                   */
CPPM(RexxInteger::minus),
CPPM(RexxInteger::multiply),
CPPM(RexxInteger::divide),
CPPM(RexxInteger::integerDivide),
CPPM(RexxInteger::remainder),
CPPM(RexxInteger::power),
CPPM(RexxInteger::notOp),
CPPM(RexxInteger::andOp),
CPPM(RexxInteger::orOp),
CPPM(RexxInteger::xorOp),
CPPM(RexxInteger::equal),
CPPM(RexxInteger::notEqual),
CPPM(RexxInteger::strictEqual),
CPPM(RexxInteger::hashCode),
CPPM(RexxInteger::strictNotEqual),
CPPM(RexxInteger::isGreaterThan),
CPPM(RexxInteger::isLessThan),
CPPM(RexxInteger::isGreaterOrEqual),
CPPM(RexxInteger::isLessOrEqual),
CPPM(RexxInteger::strictGreaterThan),
CPPM(RexxInteger::strictLessThan),
CPPM(RexxInteger::strictGreaterOrEqual),
CPPM(RexxInteger::strictLessOrEqual),
CPPM(RexxInteger::abs),
CPPM(RexxInteger::sign),
CPPM(RexxInteger::Max),
CPPM(RexxInteger::Min),
CPPM(RexxInteger::d2x),
CPPM(RexxInteger::d2c),
CPPM(RexxInteger::format),
CPPM(RexxInteger::trunc),
CPPM(RexxInteger::floor),
CPPM(RexxInteger::ceiling),
CPPM(RexxInteger::round),
CPPM(RexxInteger::classObject),
 
CPPM(RexxList::value),                 /* list methods                      */
CPPM(RexxList::remove),
CPPM(RexxList::firstRexx),
CPPM(RexxList::lastRexx),
CPPM(RexxList::next),
CPPM(RexxList::previous),
CPPM(RexxList::hasIndex),
CPPM(RexxList::supplier),
CPPM(RexxList::itemsRexx),
CPPM(RexxList::put),
CPPM(RexxList::section),
CPPM(RexxList::firstItem),
CPPM(RexxList::lastItem),
CPPM(RexxList::insertRexx),
CPPM(RexxList::append),
CPPM(RexxList::allIndexes),
CPPM(RexxList::allItems),
CPPM(RexxList::empty),
CPPM(RexxList::isEmpty),
CPPM(RexxList::index),
CPPM(RexxList::hasItem),
CPPM(RexxList::removeItem),
 
CPPM(RexxList::newRexx),
CPPM(RexxList::classOf),
 
CPPM(RexxMessage::notify),             /* Message methods                   */
CPPM(RexxMessage::result),
CPPM(RexxMessage::send),
CPPM(RexxMessage::start),
CPPM(RexxMessage::completed),
CPPM(RexxMessage::hasError),
CPPM(RexxMessage::errorCondition),
CPPM(RexxMessage::messageTarget),
CPPM(RexxMessage::messageName),
CPPM(RexxMessage::arguments),
 
CPPM(RexxMessage::newRexx),
 
CPPM(RexxMethod::setUnguardedRexx),    /* Method methods                    */
CPPM(RexxMethod::setGuardedRexx),
CPPM(BaseExecutable::source),
CPPM(BaseExecutable::getPackage),
CPPM(RexxMethod::setPrivateRexx),
CPPM(RexxMethod::setProtectedRexx),
CPPM(RexxMethod::setSecurityManager),
CPPM(RexxMethod::isGuardedRexx),
CPPM(RexxMethod::isPrivateRexx),
CPPM(RexxMethod::isProtectedRexx),
CPPM(RexxMethod::isPackageRexx), // ooRexx5
CPPM(RexxMethod::isAbstractRexx), // ooRexx5
CPPM(RexxMethod::isConstantRexx), // ooRexx5
CPPM(RexxMethod::isAttributeRexx), // ooRexx5
CPPM(RexxMethod::getScopeRexx), // ooRexx5
 
CPPM(RexxMethod::newFileRexx),
CPPM(RexxMethod::newRexx),
CPPM(RexxMethod::loadExternalMethod),
 
CPPM(RoutineClass::setSecurityManager),
CPPM(RoutineClass::callRexx),
CPPM(RoutineClass::callWithRexx),
 
CPPM(RoutineClass::newFileRexx),
CPPM(RoutineClass::newRexx),
CPPM(RoutineClass::loadExternalRoutine),
 
CPPM(PackageClass::setSecurityManager),
CPPM(PackageClass::getSource),
CPPM(PackageClass::getSourceLineRexx),
CPPM(PackageClass::getSourceSize),
CPPM(PackageClass::getClasses),
CPPM(PackageClass::getPublicClasses),
CPPM(PackageClass::getImportedClasses),
CPPM(PackageClass::getMethods),
CPPM(PackageClass::getRoutines),
CPPM(PackageClass::getPublicRoutines),
CPPM(PackageClass::getImportedRoutines),
CPPM(PackageClass::getImportedPackages),
CPPM(PackageClass::loadPackage),
CPPM(PackageClass::addPackage),
CPPM(PackageClass::findClassRexx),
CPPM(PackageClass::findRoutineRexx),
CPPM(PackageClass::findProgramRexx),
CPPM(PackageClass::addRoutine),
CPPM(PackageClass::addPublicRoutine),
CPPM(PackageClass::addClass),
CPPM(PackageClass::addPublicClass),
CPPM(PackageClass::getName),
CPPM(PackageClass::loadLibrary),
CPPM(PackageClass::digits),
CPPM(PackageClass::form),
CPPM(PackageClass::fuzz),
CPPM(PackageClass::trace),
CPPM(PackageClass::setEncodingRexx),
 
CPPM(PackageClass::newRexx),
 
CPPM(RexxNumberString::formatRexx),    /* NumberString methods              */
CPPM(RexxNumberString::trunc),
CPPM(RexxNumberString::floor),
CPPM(RexxNumberString::ceiling),
CPPM(RexxNumberString::round),
CPPM(RexxNumberString::equal),
CPPM(RexxNumberString::notEqual),
CPPM(RexxNumberString::isLessThan),
CPPM(RexxNumberString::isGreaterThan),
CPPM(RexxNumberString::isGreaterOrEqual),
CPPM(RexxNumberString::isLessOrEqual),
CPPM(RexxNumberString::strictNotEqual),
CPPM(RexxNumberString::strictLessThan),
CPPM(RexxNumberString::strictGreaterThan),
CPPM(RexxNumberString::strictGreaterOrEqual),
CPPM(RexxNumberString::strictLessOrEqual),
CPPM(RexxNumberString::plus),
CPPM(RexxNumberString::minus),
CPPM(RexxNumberString::multiply),
CPPM(RexxNumberString::divide),
CPPM(RexxNumberString::integerDivide),
CPPM(RexxNumberString::remainder),
CPPM(RexxNumberString::power),
CPPM(RexxNumberString::abs),
CPPM(RexxNumberString::Sign),
CPPM(RexxNumberString::notOp),
CPPM(RexxNumberString::andOp),
CPPM(RexxNumberString::orOp),
CPPM(RexxNumberString::xorOp),
CPPM(RexxNumberString::Max),
CPPM(RexxNumberString::Min),
CPPM(RexxNumberString::isInteger),
CPPM(RexxNumberString::d2c),
CPPM(RexxNumberString::d2x),
CPPM(RexxNumberString::d2xD2c),
CPPM(RexxNumberString::strictEqual),
CPPM(RexxNumberString::hashCode),
CPPM(RexxNumberString::classObject),
 
CPPM(RexxQueue::supplier),             /* Queue methods                     */
CPPM(RexxQueue::pushRexx),
CPPM(RexxQueue::queueRexx),
CPPM(RexxQueue::pullRexx),
CPPM(RexxQueue::peek),
CPPM(RexxQueue::put),
CPPM(RexxQueue::at),
CPPM(RexxQueue::hasindex),
CPPM(RexxQueue::remove),
CPPM(RexxQueue::append),
CPPM(RexxQueue::allIndexes),
CPPM(RexxQueue::index),
CPPM(RexxQueue::firstRexx),
CPPM(RexxQueue::lastRexx),
CPPM(RexxQueue::next),
CPPM(RexxQueue::previous),
CPPM(RexxQueue::insert),
CPPM(RexxQueue::section),
 
CPPM(RexxQueue::newRexx),
CPPM(RexxQueue::ofRexx),
 
CPPM(RexxStem::bracket),               /* Stem methods                      */
CPPM(RexxStem::bracketEqual),
CPPM(RexxStem::request),
CPPM(RexxStem::supplier),
CPPM(RexxStem::allIndexes),
CPPM(RexxStem::allItems),
CPPM(RexxStem::empty),
CPPM(RexxStem::isEmpty),
CPPM(RexxStem::itemsRexx),
CPPM(RexxStem::hasIndex),
CPPM(RexxStem::remove),
CPPM(RexxStem::index),
CPPM(RexxStem::hasItem),
CPPM(RexxStem::removeItem),
CPPM(RexxStem::toDirectory),
 
CPPM(RexxStem::newRexx),
 
CPPM(RexxString::lengthRexx),          /* String methods                    */
CPPM(RexxString::concatRexx),
CPPM(RexxString::concatBlank),
CPPM(RexxString::concatWith),
CPPM(RexxString::equal),
CPPM(RexxString::notEqual),
CPPM(RexxString::isLessThan),
CPPM(RexxString::isGreaterThan),
CPPM(RexxString::isGreaterOrEqual),
CPPM(RexxString::isLessOrEqual),
CPPM(RexxString::strictEqual),
CPPM(RexxString::strictNotEqual),
CPPM(RexxString::strictLessThan),
CPPM(RexxString::strictGreaterThan),
CPPM(RexxString::strictGreaterOrEqual),
CPPM(RexxString::strictLessOrEqual),
CPPM(RexxString::plus),
CPPM(RexxString::minus),
CPPM(RexxString::multiply),
CPPM(RexxString::divide),
CPPM(RexxString::integerDivide),
CPPM(RexxString::remainder),
CPPM(RexxString::power),
CPPM(RexxString::abs),
CPPM(RexxString::sign),
CPPM(RexxString::notOp),
CPPM(RexxString::andOp),
CPPM(RexxString::orOp),
CPPM(RexxString::xorOp),
CPPM(RexxString::Max),
CPPM(RexxString::Min),
CPPM(RexxString::isInteger),
CPPM(RexxString::isASCIIRexx),
CPPM(RexxString::upperRexx),
CPPM(RexxString::lowerRexx),
CPPM(RexxString::setEncodingRexx),
CPPM(RexxString::setTextRexx),
 
                                          /* All BIF methods start here.  They */
                                          /*  will be arranged according to the*/
                                          /*  they are defined in.             */
 
                                          /* following methods are in OKBSUBS  */
CPPM(RexxString::center),
CPPM(RexxString::delstr),
CPPM(RexxString::insert),
CPPM(RexxString::left),
CPPM(RexxString::overlay),
CPPM(RexxString::reverse),
CPPM(RexxString::right),
CPPM(RexxString::strip),
CPPM(RexxString::substr),
CPPM(RexxString::subchar),
CPPM(RexxString::replaceAt),
 
                                          /* following methods are in OKBWORD  */
CPPM(RexxString::delWord),
CPPM(RexxString::space),
CPPM(RexxString::subWord),
CPPM(RexxString::subWords),
CPPM(RexxString::word),
CPPM(RexxString::wordIndex),
CPPM(RexxString::wordLength),
CPPM(RexxString::wordPos),
CPPM(RexxString::caselessWordPos),
CPPM(RexxString::words),
 
                                          /* following methods are in OKBMISC  */
 
CPPM(RexxString::changeStr),
CPPM(RexxString::caselessChangeStr),
CPPM(RexxString::countStrRexx),
CPPM(RexxString::caselessCountStrRexx),
CPPM(RexxString::abbrev),
CPPM(RexxString::caselessAbbrev),
CPPM(RexxString::compare),
CPPM(RexxString::caselessCompare),
CPPM(RexxString::copies),
CPPM(RexxString::dataType),
CPPM(RexxString::lastPosRexx),
CPPM(RexxString::posRexx),
CPPM(RexxString::caselessLastPosRexx),
CPPM(RexxString::caselessPosRexx),
CPPM(RexxString::translate),
CPPM(RexxString::verify),
 
                                          /* following methods are in OKBBITS  */
CPPM(RexxString::bitAnd),
CPPM(RexxString::bitOr),
CPPM(RexxString::bitXor),
 
                                          /* following methods are in OKBCONV  */
 
CPPM(RexxString::b2x),
CPPM(RexxString::c2d),
CPPM(RexxString::c2x),
CPPM(RexxString::d2c),
CPPM(RexxString::d2x),
CPPM(RexxString::x2b),
CPPM(RexxString::x2c),
CPPM(RexxString::x2d),
CPPM(RexxString::format),
CPPM(RexxString::trunc),
CPPM(RexxString::floor),
CPPM(RexxString::ceiling),
CPPM(RexxString::round),
CPPM(RexxString::x2dC2d),
CPPM(RexxString::encodeBase64),
CPPM(RexxString::decodeBase64),
 
CPPM(RexxString::match),
CPPM(RexxString::caselessMatch),
CPPM(RexxString::matchChar),
CPPM(RexxString::caselessMatchChar),
CPPM(RexxString::equals),
CPPM(RexxString::caselessEquals),
CPPM(RexxString::compareToRexx),
CPPM(RexxString::caselessCompareToRexx),
                                          /* End of BIF methods                */
CPPM(RexxString::makeArrayRexx),
 
CPPM(RexxString::newRexx),
CPPM(RexxMutableBufferClass::newRexx),
CPPM(RexxMutableBuffer::lengthRexx),
CPPM(RexxMutableBuffer::makeArrayRexx),
CPPM(RexxMutableBuffer::append),
CPPM(RexxMutableBuffer::insert),
CPPM(RexxMutableBuffer::overlay),
CPPM(RexxMutableBuffer::mydelete),
CPPM(RexxMutableBuffer::substr),
CPPM(RexxMutableBuffer::subchar),
CPPM(RexxMutableBuffer::posRexx),
CPPM(RexxMutableBuffer::lastPos),
CPPM(RexxMutableBuffer::caselessPos),
CPPM(RexxMutableBuffer::caselessLastPos),
CPPM(RexxMutableBuffer::getBufferSize),
CPPM(RexxMutableBuffer::setBufferSize),
CPPM(RexxMutableBuffer::replaceAt),
CPPM(RexxMutableBuffer::countStrRexx),
CPPM(RexxMutableBuffer::caselessCountStrRexx),
CPPM(RexxMutableBuffer::changeStr),
CPPM(RexxMutableBuffer::caselessChangeStr),
CPPM(RexxMutableBuffer::upper),
CPPM(RexxMutableBuffer::lower),
CPPM(RexxMutableBuffer::translate),
CPPM(RexxMutableBuffer::match),
CPPM(RexxMutableBuffer::caselessMatch),
CPPM(RexxMutableBuffer::matchChar),
CPPM(RexxMutableBuffer::caselessMatchChar),
CPPM(RexxMutableBuffer::verify),
CPPM(RexxMutableBuffer::space),
CPPM(RexxMutableBuffer::subWord),
CPPM(RexxMutableBuffer::subWords),
CPPM(RexxMutableBuffer::word),
CPPM(RexxMutableBuffer::wordIndex),
CPPM(RexxMutableBuffer::wordLength),
CPPM(RexxMutableBuffer::words),
CPPM(RexxMutableBuffer::wordPos),
CPPM(RexxMutableBuffer::caselessWordPos),
CPPM(RexxMutableBuffer::delWord),
CPPM(RexxMutableBuffer::isASCIIRexx),
CPPM(RexxMutableBuffer::setEncodingRexx),
 
CPPM(RexxSupplier::available),         /* Supplier methods                  */
CPPM(RexxSupplier::next),
CPPM(RexxSupplier::value),
CPPM(RexxSupplier::index),
CPPM(RexxSupplier::initRexx),
 
CPPM(RexxSupplierClass::newRexx),
 
                                       /* Table methods                     */
CPPM(RexxHashTableCollection::removeRexx),
CPPM(RexxHashTableCollection::getRexx),
CPPM(RexxHashTableCollection::putRexx),
CPPM(RexxHashTableCollection::addRexx),
CPPM(RexxHashTableCollection::allAt),
CPPM(RexxHashTableCollection::hasIndexRexx),
CPPM(RexxHashTableCollection::merge),
CPPM(RexxHashTableCollection::supplier),
CPPM(RexxHashTableCollection::allItems),
CPPM(RexxHashTableCollection::allIndexes),
CPPM(RexxHashTableCollection::uniqueIndexes),
CPPM(RexxHashTableCollection::empty),
CPPM(RexxHashTableCollection::isEmpty),
CPPM(RexxHashTableCollection::indexRexx),
CPPM(RexxHashTableCollection::hasItemRexx),
CPPM(RexxHashTableCollection::removeItemRexx),
 
CPPM(RexxTable::itemsRexx),
CPPM(RexxTable::newRexx),
 
CPPM(RexxIdentityTable::newRexx),
 
CPPM(RexxRelation::put),               /* Relation methods                  */
CPPM(RexxRelation::removeItemRexx),
CPPM(RexxRelation::removeAll),
CPPM(RexxRelation::allIndex),
CPPM(RexxRelation::itemsRexx),
CPPM(RexxRelation::supplier),
CPPM(RexxRelation::hasItem),
 
CPPM(RexxRelation::newRexx),
 
CPPM(RexxLocal::local),                /* the .local environment methods    */
 
CPPM(RexxPointer::equal),
CPPM(RexxPointer::notEqual),
CPPM(RexxPointer::newRexx),
CPPM(RexxPointer::isNull),
 
CPPM(RexxBuffer::newRexx),
 
CPPM(WeakReference::newRexx),
CPPM(WeakReference::value),
 
CPPM(RexxContext::newRexx),
CPPM(RexxContext::copyRexx),
CPPM(RexxContext::getPackage),
CPPM(RexxContext::getDigits),
CPPM(RexxContext::getDigitsPropagate),
CPPM(RexxContext::getFuzz),
CPPM(RexxContext::getForm),
CPPM(RexxContext::getVariables),
CPPM(RexxContext::getExecutable),
CPPM(RexxContext::getArgs),
CPPM(RexxContext::setArgs),
CPPM(RexxContext::getNamedArgs),
CPPM(RexxContext::getCondition),
CPPM(RexxContext::getLine),
CPPM(RexxContext::getRS),
CPPM(RexxContext::getName),
CPPM(RexxContext::getStackFrames),
CPPM(RexxContext::getParentContextObject),
 
CPPM(StackFrameClass::getName),
CPPM(StackFrameClass::getExecutable),
CPPM(StackFrameClass::getLine),
CPPM(StackFrameClass::getTraceLine),
CPPM(StackFrameClass::getType),
CPPM(StackFrameClass::getTarget),
CPPM(StackFrameClass::getArguments),
CPPM(StackFrameClass::newRexx),
 
CPPM(RexxBlock::newRexx),
CPPM(RexxBlock::copyRexx),
CPPM(RexxBlock::getSource),
CPPM(RexxBlock::getPackage),
CPPM(RexxBlock::getVariables),
CPPM(RexxBlock::getKind),
CPPM(RexxBlock::getRawExecutable),
 
CPPM(RexxText::newRexx),
 
CPPM(Unicode::newRexx),
CPPM(Unicode::copyRexx),
CPPM(Unicode::systemIsLittleEndian),
 
CPPM(Unicode::utf8proc_version),
CPPM(Unicode::utf8proc_graphemeBreak),
CPPM(Unicode::utf8proc_codepointCategory),
CPPM(Unicode::utf8proc_codepointCombiningClass),
CPPM(Unicode::utf8proc_codepointBidiClass),
CPPM(Unicode::utf8proc_codepointBidiMirrored),
CPPM(Unicode::utf8proc_codepointDecompositionType),
CPPM(Unicode::utf8proc_codepointIgnorable),
CPPM(Unicode::utf8proc_codepointControlBoundary),
CPPM(Unicode::utf8proc_codepointCharWidth),
CPPM(Unicode::utf8proc_codepointBoundClass),
CPPM(Unicode::utf8proc_codepointToLowerSimple),
CPPM(Unicode::utf8proc_codepointToUpperSimple),
CPPM(Unicode::utf8proc_codepointToTitleSimple),
CPPM(Unicode::utf8proc_codepointIsLower),
CPPM(Unicode::utf8proc_codepointIsUpper),
CPPM(Unicode::utf8proc_transform),
 
CPPM(Unicode::unialgo_version),
 
NULL                                   /* final terminating method          */
};
 
 
/**
 * Resolve the entry point of a CPP method into a CPPCode wrapper
 * for that method.
 *
 * @param name   The name of the method (used for error reporting)
 * @param targetMethod
 *               The method to wrapper
 * @param argumentCount
 *               The argument descriptor.
 *
 * @return A CPPCode object for the wrappered method.
 */
CPPCode *CPPCode::resolveExportedMethod(const char *name, PCPPM targetMethod, size_t argumentCount, bool passNamedArgs)
{
    for (size_t i = 0; exportedMethods[i] != NULL; i++)
    {
        // found the one we need?  Wrap a CPPCode object around it
        if (exportedMethods[i] == targetMethod)
        {
            return new CPPCode(i, targetMethod, argumentCount, passNamedArgs);
        }
    }
 
    char buffer[256];
    snprintf(buffer, sizeof buffer, "Unresolved exported method:  %s", name);
    /* this is a bad error               */
    Interpreter::logicError(buffer);
    return NULL;                         /* needs a return value              */
}