#include <RoutineClass.hpp>

Inheritance diagram for RoutineClass:

Public Member Functions
void *	operator new (size_t)

void *	operator new (size_t size, void *ptr)

	RoutineClass (RexxString n, BaseCode _code)

	RoutineClass (RexxString *name)

	RoutineClass (RexxString name, RexxBuffer source)

	RoutineClass (RexxString name, const char data, size_t length)

	RoutineClass (RexxString name, RexxArray source, size_t startLine=0, RexxString *programName=OREF_NULL)

	RoutineClass (RESTORETYPE restoreType)

void	execute (RexxObject , RexxObject )

void	live (size_t)

void	liveGeneral (int reason)

void	flatten (RexxEnvelope *)

void	call (RexxActivity , RexxString , RexxObject *, size_t, size_t, RexxString , RexxString *, int, ProtectedObject &)

void	call (RexxActivity , RexxString , RexxObject **, size_t, size_t, ProtectedObject &)

void	runProgram (RexxActivity activity, RexxString calltype, RexxString environment, RexxObject *arguments, size_t argCount, size_t named_argCount, ProtectedObject &result)

void	runProgram (RexxActivity activity, RexxObject *arguments, size_t argCount, size_t named_argCount, ProtectedObject &result)

RexxObject *	callRexx (RexxObject **, size_t, size_t)

RexxObject *	callWithRexx (RexxArray , RexxObject *, size_t)

RexxBuffer *	save ()

void	save (PRXSTRING outBuffer)

void	save (const char *filename)

RexxObject *	setSecurityManager (RexxObject *)

RoutineClass *	newRexx (RexxObject **, size_t, size_t)

RoutineClass *	newFileRexx (RexxString *)

RoutineClass *	loadExternalRoutine (RexxString name, RexxString descriptor)

Public Member Functions inherited from BaseExecutable
RexxSource *	getSourceObject ()

BaseCode *	getCode ()

RexxArray *	getSource ()

PackageClass *	getPackage ()

RexxArray *	source ()

RexxClass *	findClass (RexxString *className)

BaseExecutable *	setSourceObject (RexxSource *s)

RexxString *	getName ()

void	setName (RexxString *name)

Public Member Functions inherited from RexxObject
void *	operator new (size_t, RexxClass *)

void *	operator new (size_t, RexxClass , RexxObject *, size_t, size_t)

void *	operator new (size_t size, void *objectPtr)

void	operator delete (void , void )

void	operator delete (void *)

void	operator delete (void , RexxClass )

void	operator delete (void , RexxClass , RexxObject **, size_t)

RexxObject *	newRexx (RexxObject **arguments, size_t argCount, size_t named_argCount)

RexxObject *	newObject ()

	operator RexxInternalObject * ()

	RexxObject ()

	RexxObject (RESTORETYPE restoreType)

void	initializeNewObject (size_t size, size_t mark, void vft, RexxBehaviour b)

void	initializeNewObject (size_t mark, void vft, RexxBehaviour b)

virtual	~RexxObject ()

virtual RexxObject *	defMethod (RexxString , RexxMethod , RexxString *a=OREF_NULL)

virtual RexxString *	defaultName ()

virtual RexxObject *	unknown (RexxString msg, RexxArray args, RexxDirectory *named_args)

virtual RexxInteger *	hasMethod (RexxString *msg)

bool	hasUninitMethod ()

RexxObject *	init ()

void	uninit ()

void	live (size_t)

void	liveGeneral (int reason)

void	flatten (RexxEnvelope *)

RexxObject *	copy ()

HashCode	hash ()

bool	truthValue (int)

virtual bool	logicalValue (logical_t &)

virtual bool	numberValue (wholenumber_t &result, size_t precision)

virtual bool	numberValue (wholenumber_t &result)

virtual bool	unsignedNumberValue (stringsize_t &result, size_t precision)

virtual bool	unsignedNumberValue (stringsize_t &result)

virtual bool	doubleValue (double &result)

RexxNumberString *	numberString ()

RexxInteger *	integerValue (size_t)

RexxString *	makeString ()

RexxString *	primitiveMakeString ()

void	copyIntoTail (RexxCompoundTail *buffer)

RexxArray *	makeArray ()

RexxString *	stringValue ()

RexxString *	requestString ()

RexxString *	requestStringNoNOSTRING ()

RexxInteger *	requestInteger (size_t)

bool	requestNumber (wholenumber_t &, size_t)

bool	requestUnsignedNumber (stringsize_t &, size_t)

RexxArray *	requestArray ()

RexxDirectory *	requestDirectory ()

RexxString *	requiredString (RexxString *kind, size_t)

RexxString *	requiredString (RexxString kind, const char )

RexxString *	requiredString ()

RexxInteger *	requiredInteger (RexxString *kind, size_t, size_t)

wholenumber_t	requiredNumber (RexxString *kind, size_t position, size_t precision=Numerics::ARGUMENT_DIGITS)

stringsize_t	requiredPositive (RexxString *kind, size_t position, size_t precision=Numerics::ARGUMENT_DIGITS)

stringsize_t	requiredNonNegative (RexxString *kind, size_t position, size_t precision=Numerics::ARGUMENT_DIGITS)

bool	isEqual (RexxObject *)

bool	isInstanceOf (RexxClass *)

RexxObject *	isInstanceOfRexx (RexxClass *)

RexxMethod *	instanceMethod (RexxString *)

RexxSupplier *	instanceMethods (RexxClass *)

RexxMethod *	instanceMethodRexx (RexxString *)

RexxSupplier *	instanceMethodsRexx (RexxClass *)

RexxString *	objectName ()

RexxObject *	objectNameEquals (RexxObject *)

RexxClass *	classObject ()

RexxObject *	setMethod (RexxString , RexxMethod , RexxString *a=OREF_NULL)

RexxObject *	unsetMethod (RexxString *)

RexxObject *	requestRexx (RexxString *)

RexxMessage *	start (RexxObject **, size_t, size_t)

RexxMessage *	startWith (RexxObject , RexxArray , RexxObject **, size_t)

RexxObject *	send (RexxObject **, size_t, size_t)

RexxObject *	sendWith (RexxObject , RexxArray , RexxObject **, size_t)

RexxMessage *	startCommon (RexxObject message, RexxObject *arguments, size_t argCount, size_t named_argCount)

RexxString *	oref ()

RexxObject *	pmdict ()

RexxObject *	run (RexxObject **, size_t, size_t)

bool	messageSend (RexxString , RexxObject *, size_t, size_t, ProtectedObject &, bool processUnknown=true)

bool	messageSend (RexxString , RexxObject , size_t, size_t, RexxObject , ProtectedObject &, bool processUnknown=true)

RexxMethod *	checkPrivate (RexxMethod *)

void	processUnknown (RexxString , RexxObject *, size_t, size_t, ProtectedObject &)

void	processProtectedMethod (RexxString , RexxMethod , RexxObject **, size_t, size_t, ProtectedObject &)

void	sendMessage (RexxString , RexxArray , RexxDirectory *, ProtectedObject &)

void	sendMessage (RexxString message, RexxObject *args, size_t argCount, size_t named_argCount, ProtectedObject &result)

void	sendMessage (RexxString *message, ProtectedObject &result)

void	sendMessage (RexxString message, RexxObject argument1, ProtectedObject &result)

void	sendMessage (RexxString , RexxObject , RexxObject *, ProtectedObject &)

void	sendMessage (RexxString , RexxObject , RexxObject , RexxObject , ProtectedObject &)

void	sendMessage (RexxString , RexxObject , RexxObject , RexxObject , RexxObject *, ProtectedObject &)

void	sendMessage (RexxString , RexxObject , RexxObject , RexxObject , RexxObject , RexxObject , ProtectedObject &)

RexxObject *	sendMessage (RexxString , RexxArray , RexxDirectory *=OREF_NULL)

RexxObject *	sendMessage (RexxString message, RexxObject *args, size_t argCount, size_t named_argCount)

RexxObject *	sendMessage (RexxString *message)

RexxObject *	sendMessage (RexxString message, RexxObject argument1)

RexxObject *	sendMessage (RexxString , RexxObject , RexxObject *)

RexxObject *	sendMessage (RexxString , RexxObject , RexxObject , RexxObject )

RexxObject *	sendMessage (RexxString , RexxObject , RexxObject , RexxObject , RexxObject *)

RexxObject *	sendMessage (RexxString , RexxObject , RexxObject , RexxObject , RexxObject , RexxObject )

RexxObject *	defMethods (RexxDirectory *)

void	setObjectVariable (RexxString , RexxObject , RexxObject *)

RexxObject *	getObjectVariable (RexxString *)

RexxObject *	getObjectVariable (RexxString , RexxObject )

void	addObjectVariables (RexxVariableDictionary *)

void	copyObjectVariables (RexxObject *newObject)

RexxObject *	superScope (RexxObject *)

RexxMethod *	superMethod (RexxString , RexxObject )

RexxObject *	mdict ()

RexxObject *	setMdict (RexxObject *)

RexxBehaviour *	behaviourObject ()

const char *	idString ()

RexxString *	id ()

RexxMethod *	methodLookup (RexxString *name)

RexxVariableDictionary *	getObjectVariables (RexxObject *)

void	guardOn (RexxActivity activity, RexxObject scope)

void	guardOff (RexxActivity activity, RexxObject scope)

RexxObject *	equal (RexxObject *)

RexxObject *	notEqual (RexxObject *other)

RexxObject *	strictEqual (RexxObject *)

RexxObject *	strictNotEqual (RexxObject *other)

RexxInteger *	identityHashRexx ()

RexxObject *	hashCode ()

RexxString *	stringRexx ()

RexxString *	concatRexx (RexxObject *)

RexxString *	concatBlank (RexxObject *)

RexxObject *	makeStringRexx ()

RexxObject *	makeArrayRexx ()

RexxString *	defaultNameRexx ()

RexxObject *	copyRexx ()

RexxObject *	unknownRexx (RexxString , RexxArray , RexxObject **, size_t)

RexxObject *	hasMethodRexx (RexxString *)

void *	getCSelf ()

void *	getCSelf (RexxObject *scope)

bool	equalValue (RexxObject *other)

virtual wholenumber_t	compareTo (RexxObject *)

	koper (operator_plus) koper(operator_minus) koper(operator_multiply) koper(operator_divide) koper(operator_integerDivide) koper(operator_remainder) koper(operator_power) koper(operator_abuttal) koper(operator_concat) koper(operator_concatBlank) koper(operator_equal) koper(operator_notEqual) koper(operator_isGreaterThan) koper(operator_isBackslashGreaterThan) koper(operator_isLessThan) koper(operator_isBackslashLessThan) koper(operator_isGreaterOrEqual) koper(operator_isLessOrEqual) koper(operator_strictEqual) koper(operator_strictNotEqual) koper(operator_strictGreaterThan) koper(operator_strictBackslashGreaterThan) koper(operator_strictLessThan) koper(operator_strictBackslashLessThan) koper(operator_strictGreaterOrEqual) koper(operator_strictLessOrEqual) koper(operator_lessThanGreaterThan) koper(operator_greaterThanLessThan) koper(operator_and) koper(operator_or) koper(operator_xor) koper(operator_not) RexxVariableDictionary *objectVariables

Public Member Functions inherited from RexxInternalObject
void *	operator new (size_t, RexxClass *)

void *	operator new (size_t, RexxClass , RexxObject *, size_t, size_t)

void *	operator new (size_t size, void *ptr)

void	operator delete (void *)

void	operator delete (void p, void ptr)

	RexxInternalObject ()

	RexxInternalObject (RESTORETYPE restoreType)

virtual	~RexxInternalObject ()

	operator RexxObject * ()

size_t	getObjectSize ()

void	setObjectSize (size_t s)

size_t	getObjectDataSize ()

void *	getObjectDataSpace ()

void	clearObject ()

void	clearObject (size_t l)

void	setVirtualFunctions (void *t)

void	setInitHeader (size_t s, size_t markword)

void	setInitHeader (size_t markword)

void	setObjectLive (size_t markword)

void	setHasReferences ()

void	setHasNoReferences ()

bool	hasReferences ()

bool	hasNoReferences ()

void	setPrimitive ()

void	setNonPrimitive ()

bool	isPrimitive ()

bool	isNonPrimitive ()

bool	isObjectMarked (size_t markword)

void	setObjectMark (size_t markword)

void	clearObjectMark ()

bool	isObjectLive (size_t mark)

bool	isObjectDead (size_t mark)

bool	isOldSpace ()

bool	isNewSpace ()

void	setNewSpace ()

void	setOldSpace ()

void	makeProxiedObject ()

bool	isProxyObject ()

bool	isSubClassOrEnhanced ()

bool	isBaseClass ()

size_t	getObjectTypeNumber ()

RexxBehaviour *	getObjectType ()

bool	isObjectType (RexxBehaviour *b)

bool	isObjectType (size_t t)

bool	isSameType (RexxInternalObject *o)

void	setBehaviour (RexxBehaviour *b)

virtual RexxObject *	makeProxy (RexxEnvelope *)

virtual RexxObject *	evaluate (RexxActivation , RexxExpressionStack )

virtual RexxObject *	getValue (RexxActivation *)

virtual RexxObject *	getValue (RexxVariableDictionary *)

virtual RexxObject *	getRealValue (RexxActivation *)

virtual RexxObject *	getRealValue (RexxVariableDictionary *)

virtual HashCode	getHashValue ()

HashCode	identityHash ()

void	hasUninit ()

void	removedUninit ()

void	printObject ()

RexxObject *	clone ()

Public Member Functions inherited from RexxVirtualBase
virtual RexxObject *	unflatten (RexxEnvelope *)

Static Public Member Functions
static RoutineClass *	restore (RexxBuffer , char , size_t length)

static RoutineClass *	restore (const char *data, size_t length)

static RoutineClass *	restore (RexxString fileName, RexxBuffer buffer)

static RoutineClass *	restoreFromMacroSpace (RexxString *name)

static RoutineClass *	restore (RexxBuffer *buffer)

static RoutineClass *	restore (RXSTRING inData, RexxString name)

static RoutineClass *	fromFile (RexxString *filename)

static RoutineClass *	newRoutineObject (RexxString , RexxObject , RexxObject , RexxSource s, bool isBlock)

static RoutineClass *	newRoutineObject (RexxString , RexxArray , RexxObject *)

static RoutineClass *	processInstore (PRXSTRING instore, RexxString *name)

static void	createInstance ()

Static Public Member Functions inherited from RexxObject
static void	decodeMessageName (RexxObject target, RexxObject message, RexxString &messageName, RexxObject &startScope)

static void	createInstance ()

Static Public Member Functions inherited from RexxInternalObject
static size_t	getObjectHeaderSize ()

Static Public Attributes
static RexxClass *	classInstance = OREF_NULL

Static Public Attributes inherited from RexxObject
static PCPPM	operatorMethods []

static RexxClass *	classInstance = OREF_NULL

Additional Inherited Members
Public Attributes inherited from RexxInternalObject
ObjectHeader	header

RexxBehaviour *	behaviour

Protected Member Functions inherited from RexxVirtualBase
virtual	~RexxVirtualBase ()

virtual void	baseVirtual ()

Protected Attributes inherited from BaseExecutable
RexxString *	executableName

BaseCode *	code

Detailed Description

Definition at line 49 of file RoutineClass.hpp.

Constructor & Destructor Documentation

◆ RoutineClass() [1/6]

RoutineClass::RoutineClass	(	RexxString *	name,
		BaseCode *	codeObj
	)

Initialize a Routine object from a generated code object. Generally used for routines generated from ::ROUTINE directives.

Parameters

name	The routine name.
codeObj	The associated code object.

Definition at line 90 of file RoutineClass.cpp.

References BaseExecutable::code, BaseExecutable::executableName, and OrefSet.

Referenced by fromFile(), newFileRexx(), newRoutineObject(), and processInstore().

◆ RoutineClass() [2/6]

RoutineClass::RoutineClass ( RexxString * name )

Initialize a RoutineClass object from a file source.

Parameters

name	The routine name (and the resolved name of the file).

Definition at line 102 of file RoutineClass.cpp.

References BaseExecutable::code, BaseExecutable::executableName, RexxSource::generateCode(), and OrefSet.

◆ RoutineClass() [3/6]

RoutineClass::RoutineClass	(	RexxString *	name,
		RexxBuffer *	s
	)

Initialize a Routine object using a buffered source.

Parameters

name	The name of the routine.
source	the source buffer.

Definition at line 124 of file RoutineClass.cpp.

References BaseExecutable::code, BaseExecutable::executableName, RexxSource::generateCode(), and OrefSet.

◆ RoutineClass() [4/6]

RoutineClass::RoutineClass	(	RexxString *	name,
		const char *	data,
		size_t	length
	)

Initialize a Routine object using directly provided source.

Parameters

name	The name of the routine.
data	The source data buffer pointer.
length	the length of the source buffer.

Definition at line 147 of file RoutineClass.cpp.

References BaseExecutable::code, BaseExecutable::executableName, RexxSource::generateCode(), and OrefSet.

◆ RoutineClass() [5/6]

RoutineClass::RoutineClass	(	RexxString *	name,
		RexxArray *	s,
		size_t	startLine = `0`,
		RexxString *	programName = `OREF_NULL`
	)

Initialize a Routine object using an array source.

Parameters

name	The name of the routine.
source	the source buffer.

Definition at line 169 of file RoutineClass.cpp.

References RexxSource::adjustLine(), BaseExecutable::code, BaseExecutable::executableName, RexxSource::generateCode(), OrefSet, and RexxArray::size().

◆ RoutineClass() [6/6]

RoutineClass::RoutineClass ( RESTORETYPE restoreType )

inline

Definition at line 59 of file RoutineClass.hpp.

Member Function Documentation

◆ call() [1/2]

void RoutineClass::call	(	RexxActivity *	activity,
		RexxString *	msgname,
		RexxObject **	argPtr,
		size_t	argcount,
		size_t	named_argcount,
		ProtectedObject &	result
	)

Definition at line 221 of file RoutineClass.cpp.

References BaseCode::call(), and BaseExecutable::code.

◆ call() [2/2]

void RoutineClass::call	(	RexxActivity *	activity,
		RexxString *	msgname,
		RexxObject **	argPtr,
		size_t	argcount,
		size_t	named_argcount,
		RexxString *	calltype,
		RexxString *	environment,
		int	context,
		ProtectedObject &	result
	)

Definition at line 238 of file RoutineClass.cpp.

References BaseCode::call(), and BaseExecutable::code.

Referenced by RexxActivation::callExternalRexx(), RexxActivation::callMacroSpaceFunction(), RexxActivation::externalCall(), RexxSource::install(), CallRoutineDispatcher::run(), and InterpreterInstance::runRequires().

◆ callRexx()

RexxObject * RoutineClass::callRexx	(	RexxObject **	args,
		size_t	count,
		size_t	named_count
	)

Call a routine object from Rexx-level code.

Parameters

args	The call arguments.
count	The count of arguments.

Returns: The call result (if any).

Definition at line 266 of file RoutineClass.cpp.

References BaseCode::call(), BaseExecutable::code, ActivityManager::currentActivity, and BaseExecutable::executableName.

Referenced by RexxMemory::createImage().

◆ callWithRexx()

RexxObject * RoutineClass::callWithRexx	(	RexxArray *	args,
		RexxObject **	named_arglist,
		size_t	named_argcount
	)

Call a routine object from Rexx-level code.

Parameters

args	The call arguments.

Returns: The call result (if any).

Definition at line 282 of file RoutineClass.cpp.

References RexxDirectory::appendAllIndexesItemsTo(), ARG_ONE, arrayArgument(), BaseCode::call(), NamedArguments::check(), BaseExecutable::code, RexxArray::copy(), ActivityManager::currentActivity, RexxArray::data(), Error_Execution_user_defined, BaseExecutable::executableName, RexxDirectory::items(), OREF_NULL, reportException(), RexxObject::requestDirectory(), RexxArray::size(), and TheNilObject.

Referenced by RexxMemory::createImage().

◆ createInstance()

void RoutineClass::createInstance ( )

static

Create initial class object at bootstrap time.

Definition at line 77 of file RoutineClass.cpp.

References CLASS_CREATE.

Referenced by RexxMemory::createImage().

◆ execute()

void RoutineClass::execute	(	RexxObject *	,
		RexxObject *
	)

◆ flatten()

void RoutineClass::flatten ( RexxEnvelope * envelope )

virtual

Reimplemented from RexxVirtualBase.

Definition at line 206 of file RoutineClass.cpp.

References cleanUpFlatten, flatten_reference, and setUpFlatten.

◆ fromFile()

RoutineClass * RoutineClass::fromFile ( RexxString * filename )

static

Retrieve a routine object from a file. This will first attempt to restore a previously translated image, then will try to translate the source if that fails.

Parameters

filename The target file name.

Returns: A resulting Routine object, if possible.

Definition at line 909 of file RoutineClass.cpp.

References Error_Program_unreadable_name, RexxString::getStringData(), OREF_NULL, SystemInterpreter::readProgram(), reportException(), restore(), and RoutineClass().

Referenced by RexxActivation::callExternalRexx(), PackageManager::getRequiresFile(), RexxStartDispatcher::run(), and CallProgramDispatcher::run().

◆ live()

void RoutineClass::live ( size_t liveMark )

virtual

Reimplemented from RexxVirtualBase.

Definition at line 186 of file RoutineClass.cpp.

References BaseExecutable::code, BaseExecutable::executableName, and memory_mark.

◆ liveGeneral()

void RoutineClass::liveGeneral ( int reason )

virtual

Reimplemented from RexxVirtualBase.

Definition at line 196 of file RoutineClass.cpp.

References BaseExecutable::code, BaseExecutable::executableName, and memory_mark_general.

◆ loadExternalRoutine()

RoutineClass * RoutineClass::loadExternalRoutine	(	RexxString *	name,
		RexxString *	descriptor
	)

Create a routine from an external library source.

Parameters

name	The routine name.

Returns: The resolved routine object, or OREF_NULL if unable to load the routine.

Definition at line 939 of file RoutineClass.cpp.

References Error_Translation_bad_external, RexxArray::get(), RexxString::getBLength(), RexxString::getStringData(), PackageManager::loadRoutine(), OREF_NULL, reportException(), RexxArray::size(), stringArgument(), TheNilObject, and StringUtil::words().

Referenced by RexxMemory::createImage().

◆ newFileRexx()

RoutineClass * RoutineClass::newFileRexx ( RexxString * filename )

Definition at line 671 of file RoutineClass.cpp.

References ARG_ONE, RexxInternalObject::hasUninit(), RoutineClass(), RexxObject::sendMessage(), RexxInternalObject::setBehaviour(), and stringArgument().

Referenced by RexxMemory::createImage().

◆ newRexx()

RoutineClass * RoutineClass::newRexx	(	RexxObject **	init_args,
		size_t	argCount,
		size_t	named_argCount
	)

Definition at line 602 of file RoutineClass.cpp.

References ARG_ONE, ARG_TWO, Error_Incorrect_method_argType, Error_Logical_value_logical_list, RexxInternalObject::hasUninit(), IntegerThree, IntegerTwo, isOfClass, new_string(), newRoutineObject(), OREF_NULL, RexxClass::processNewArgs(), reportException(), requiredArgument(), RexxObject::sendMessage(), RexxInternalObject::setBehaviour(), stringArgument(), and RexxObject::truthValue().

Referenced by RexxMemory::createImage().

◆ newRoutineObject() [1/2]

RoutineClass * RoutineClass::newRoutineObject	(	RexxString *	pgmname,
		RexxArray *	source,
		RexxObject *	position
	)

static

Construct a Routine using different forms of in-memory source file.

Parameters

pgmname	The name of the program.
source	The program source. This can be a string or an array of strings.
position	The argument position used for error reporting.
parentSource	A parent source context used to provide additional class and routine definitions.

Returns: A constructed Routine object.

Definition at line 556 of file RoutineClass.cpp.

References Error_Incorrect_method_no_method, Error_Incorrect_method_noarray, Error_Incorrect_method_nostring_inarray, RexxArray::get(), RexxArray::getDimension(), IntegerTwo, RexxObject::makeString(), RexxArray::put(), reportException(), RexxObject::requestArray(), RoutineClass(), RexxArray::size(), BaseExecutable::source(), and TheNilObject.

◆ newRoutineObject() [2/2]

RoutineClass * RoutineClass::newRoutineObject	(	RexxString *	pgmname,
		RexxObject *	source,
		RexxObject *	position,
		RexxSource *	parentSource,
		bool	isBlock
	)

static

Construct a Routine using different forms of in-memory source file.

Parameters

pgmname	The name of the program.
source	The program source. This can be a string or an array of strings.
position	The argument position used for error reporting.
parentSource	A parent source context used to provide additional class and routine definitions.

Returns: A constructed Routine object.

Definition at line 459 of file RoutineClass.cpp.

References ActivityManager::currentActivity, Error_Incorrect_method_no_method, Error_Incorrect_method_noarray, Error_Incorrect_method_nostring_inarray, RexxArray::get(), RexxActivity::getCurrentRexxFrame(), RexxArray::getDimension(), RexxSource::getProgramName(), BaseExecutable::getSourceObject(), RexxActivation::getSourceObject(), RexxSource::inheritSourceContext(), IntegerTwo, RexxObject::makeString(), RexxArray::makeString(), new_array(), OREF_NULL, RexxArray::put(), reportException(), RexxObject::requestArray(), RoutineClass(), RexxSource::setIsBlock(), RexxArray::size(), BaseExecutable::source(), and TheNilObject.

Referenced by newRexx().

◆ operator new() [1/2]

void* RoutineClass::operator new	(	size_t	size,
		void *	ptr
	)

inline

Definition at line 53 of file RoutineClass.hpp.

◆ operator new() [2/2]

void * RoutineClass::operator new ( size_t size )

Definition at line 436 of file RoutineClass.cpp.

References new_object(), and T_Routine.

◆ processInstore()

RoutineClass * RoutineClass::processInstore	(	PRXSTRING	instore,
		RexxString *	name
	)

static

Definition at line 717 of file RoutineClass.cpp.

References RexxBuffer::getData(), BaseExecutable::getSourceObject(), RexxString::getStringData(), new_buffer(), OREF_NULL, restore(), restoreFromMacroSpace(), RexxQueryMacro(), RoutineClass(), save(), and RexxSource::setBufferedSource().

Referenced by RexxStartDispatcher::run(), TranslateDispatcher::run(), and TranslateInstoreDispatcher::run().

◆ restore() [1/5]

RoutineClass * RoutineClass::restore	(	const char *	data,
		size_t	length
	)

static

Restore a saved routine directly from character data.

Parameters

data	The data pointer.
length	the data length.

Returns: The unflattened routine object.

Definition at line 777 of file RoutineClass.cpp.

References RexxBuffer::getData(), new_buffer(), and restore().

◆ restore() [2/5]

RoutineClass * RoutineClass::restore	(	RexxBuffer *	buffer,
		char *	startPointer,
		size_t	length
	)

static

Definition at line 786 of file RoutineClass.cpp.

References RexxEnvelope::getReceiver(), and RexxEnvelope::puff().

Referenced by fromFile(), RexxActivation::getMacroCode(), processInstore(), restore(), and restoreFromMacroSpace().

◆ restore() [3/5]

static RoutineClass* RoutineClass::restore ( RexxBuffer * buffer )

static

◆ restore() [4/5]

RoutineClass * RoutineClass::restore	(	RexxString *	fileName,
		RexxBuffer *	buffer
	)

static

Restore a program from a simple buffer.

Parameters

buffer The source buffer.

Returns: The inflated Routine object, if valid.

Definition at line 814 of file RoutineClass.cpp.

References Error_Program_unreadable_version, RexxBuffer::getData(), RexxBufferBase::getDataLength(), ProgramMetaData::getImageData(), ProgramMetaData::getImageSize(), BaseExecutable::getSourceObject(), OREF_NULL, reportException(), restore(), RexxSource::setProgramName(), Utilities::strnchr(), and ProgramMetaData::validate().

◆ restore() [5/5]

RoutineClass * RoutineClass::restore	(	RXSTRING *	inData,
		RexxString *	name
	)

static

Restore a routine object from a previously saved instore buffer.

Parameters

inData The input data (in RXSTRING form).

Returns: The unflattened object.

Definition at line 857 of file RoutineClass.cpp.

References Error_Program_unreadable_version, ProgramMetaData::extractBufferData(), RexxBuffer::getData(), ProgramMetaData::getImageSize(), BaseExecutable::getSourceObject(), OREF_NULL, reportException(), restore(), RexxSource::setProgramName(), _RXSTRING::strlength, Utilities::strnchr(), _RXSTRING::strptr, and ProgramMetaData::validate().

◆ restoreFromMacroSpace()

RoutineClass * RoutineClass::restoreFromMacroSpace ( RexxString * name )

static

Create a routine from a macrospace source.

Parameters

name	The name of the macrospace item.

Returns: The inflatted macrospace routine.

Definition at line 702 of file RoutineClass.cpp.

References RexxString::getStringData(), MAKERXSTRING, SystemInterpreter::releaseResultMemory(), restore(), RexxResolveMacroFunction(), and _RXSTRING::strptr.

Referenced by processInstore().

◆ runProgram() [1/2]

void RoutineClass::runProgram	(	RexxActivity *	activity,
		RexxObject **	arguments,
		size_t	argCount,
		size_t	named_argCount,
		ProtectedObject &	result
	)

Definition at line 349 of file RoutineClass.cpp.

References BaseCode::call(), BaseExecutable::code, BaseExecutable::executableName, InterpreterInstance::getDefaultEnvironment(), RexxActivity::getInstance(), and PROGRAMCALL.

◆ runProgram() [2/2]

void RoutineClass::runProgram	(	RexxActivity *	activity,
		RexxString *	calltype,
		RexxString *	environment,
		RexxObject **	arguments,
		size_t	argCount,
		size_t	named_argCount,
		ProtectedObject &	result
	)

Definition at line 332 of file RoutineClass.cpp.

References BaseCode::call(), BaseExecutable::code, BaseExecutable::executableName, and PROGRAMCALL.

Referenced by RexxMemory::createImage(), RexxStartDispatcher::run(), and CallProgramDispatcher::run().

◆ save() [1/3]

RexxBuffer * RoutineClass::save ( )

Definition at line 374 of file RoutineClass.cpp.

References RexxEnvelope::pack().

Referenced by processInstore(), TranslateDispatcher::run(), and save().

◆ save() [2/3]

void RoutineClass::save ( const char * filename )

Save a routine to a target file.

Parameters

filename The name of the file (fully resolved already).

Definition at line 410 of file RoutineClass.cpp.

References Error_Program_unreadable_output_error, RexxBufferBase::getDataLength(), reportException(), save(), size_v, and ProgramMetaData::write().

◆ save() [3/3]

void RoutineClass::save ( PRXSTRING outBuffer )

Save a routine into an externalized buffer form in an RXSTRING.

Parameters

outBuffer The target output RXSTRING.

Definition at line 393 of file RoutineClass.cpp.

References ProgramMetaData::getDataSize(), save(), _RXSTRING::strlength, and _RXSTRING::strptr.

◆ setSecurityManager()

RexxObject * RoutineClass::setSecurityManager ( RexxObject * manager )

Definition at line 364 of file RoutineClass.cpp.

References BaseExecutable::code, and BaseCode::setSecurityManager().

Referenced by RexxMemory::createImage(), PackageManager::getMacroSpaceRequires(), and PackageManager::getRequiresFile().

Member Data Documentation

◆ classInstance

RexxClass * RoutineClass::classInstance = OREF_NULL

static

Definition at line 97 of file RoutineClass.hpp.

The documentation for this class was generated from the following files:

Public Member Functions

Static Public Member Functions

Static Public Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ RoutineClass() [1/6]

◆ RoutineClass() [2/6]

◆ RoutineClass() [3/6]

◆ RoutineClass() [4/6]

◆ RoutineClass() [5/6]

◆ RoutineClass() [6/6]

Member Function Documentation

◆ call() [1/2]

◆ call() [2/2]

◆ callRexx()

◆ callWithRexx()

◆ createInstance()

◆ execute()

◆ flatten()

◆ fromFile()

◆ live()

◆ liveGeneral()

◆ loadExternalRoutine()

◆ newFileRexx()

◆ newRexx()

◆ newRoutineObject() [1/2]

◆ newRoutineObject() [2/2]

◆ operator new() [1/2]

◆ operator new() [2/2]

◆ processInstore()

◆ restore() [1/5]

◆ restore() [2/5]

◆ restore() [3/5]

◆ restore() [4/5]

◆ restore() [5/5]

◆ restoreFromMacroSpace()

◆ runProgram() [1/2]

◆ runProgram() [2/2]

◆ save() [1/3]

◆ save() [2/3]

◆ save() [3/3]

◆ setSecurityManager()

Member Data Documentation

◆ classInstance