#include <SourceFile.hpp>

Inheritance diagram for RexxSource:

Collaboration diagram for RexxSource:

Public Member Functions
void *	operator new (size_t)

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

void	operator delete (void *)

void	operator delete (void , void )

	RexxSource (RexxString , RexxArray )

	RexxSource (RexxString programname, RexxBuffer source_buffer)

	RexxSource (RexxString programname, const char data, size_t length)

	RexxSource (RexxString *programname)

	RexxSource (RESTORETYPE restoreType)

void	initBuffered (RexxBuffer *)

void	initFile ()

void	extractNameInformation ()

bool	reconnect ()

void	setReconnect ()

void	setBufferedSource (RexxBuffer *newSource)

void	interpretLine (size_t)

void	comment ()

void	needVariable (RexxToken *)

void	needVariableOrDotSymbol (RexxToken *)

bool	terminator (int, RexxObject *)

void	nextLine ()

void	position (size_t, size_t)

void	live (size_t)

void	liveGeneral (int reason)

void	flatten (RexxEnvelope *)

size_t	sourceSize ()

RexxString *	get (size_t)

void	nextClause ()

RexxToken *	sourceNextToken (RexxToken *)

RexxString *	traceBack (RexxActivation *, SourceLocation &, size_t, bool)

RexxString *	extract (SourceLocation &)

RexxArray *	extractSource (SourceLocation &)

RexxArray *	extractSource ()

void	startLocation (SourceLocation &)

void	endLocation (SourceLocation &)

bool	nextSpecial (unsigned int, SourceLocation &)

unsigned int	locateToken (RexxToken *)

void	globalSetup ()

RexxString *	packLiteral (size_t, size_t, int)

RexxCode *	generateCode (bool isMethod)

RexxCode *	interpretMethod (RexxDirectory *)

RexxCode *	interpret (RexxString , RexxDirectory , size_t)

void	checkDirective (int errorCode)

bool	hasBody ()

RexxObject *	toss (RexxObject *)

void	cleanup ()

void	mergeRequired (RexxSource *)

PackageClass *	loadRequires (RexxActivity activity, RexxString target)

PackageClass *	loadRequires (RexxActivity activity, RexxString target, RexxArray *s)

void	addPackage (PackageClass *package)

PackageClass *	getPackage ()

void	inheritSourceContext (RexxSource *source)

RoutineClass *	findRoutine (RexxString *)

RoutineClass *	findLocalRoutine (RexxString *)

RoutineClass *	findPublicRoutine (RexxString *)

RexxClass *	findClass (RexxString *)

RexxClass *	findInstalledClass (RexxString *name)

RexxClass *	findPublicClass (RexxString *name)

RexxString *	resolveProgramName (RexxActivity activity, RexxString name)

void	processInstall (RexxActivation *)

void	install ()

RexxCode *	translate (RexxDirectory *)

void	resolveDependencies ()

void	directive ()

void	routineDirective ()

void	requiresDirective ()

void	libraryDirective (RexxString name, RexxToken token)

void	methodDirective ()

void	classDirective ()

void	attributeDirective ()

void	constantDirective ()

void	optionsDirective ()

void	decodeExternalMethod (RexxString methodName, RexxString externalSpec, RexxString &library, RexxString &procedure)

RexxMethod *	createNativeMethod (RexxString name, RexxString library, RexxString *procedure)

void	createMethod (RexxString *name, bool classMethod, bool privateMethod, bool protectedMethod, bool guardedMethod)

void	createAttributeGetterMethod (RexxString name, RexxVariableBase retriever, bool classMethod, bool privateMethod, bool protectedMethod, bool guardedMethod)

void	createAttributeSetterMethod (RexxString name, RexxVariableBase retriever, bool classMethod, bool privateMethod, bool protectedMethod, bool guardedMethod)

void	createConstantGetterMethod (RexxString name, RexxObject value)

void	createAbstractMethod (RexxString *name, bool classMethod, bool privateMethod, bool protectedMethod, bool guardedMethod)

void	checkDuplicateMethod (RexxString *name, bool classMethod, int errorMsg)

void	addMethod (RexxString name, RexxMethod method, bool classMethod)

void	flushControl (RexxInstruction *)

RexxCode *	translateBlock (RexxDirectory *)

RexxInstruction *	instruction ()

RexxVariableBase *	addVariable (RexxString *)

RexxStemVariable *	addStem (RexxString *)

RexxCompoundVariable *	addCompound (RexxString *)

void	expose (RexxString *)

RexxString *	commonString (RexxString *)

RexxObject *	addText (RexxToken *)

RexxObject *	addVariable (RexxToken *)

void	addClause (RexxInstruction *)

void	addLabel (RexxInstruction , RexxString )

RexxInstruction *	findLabel (RexxString *)

void	setGuard ()

RexxArray *	getGuard ()

void	addBlock (void)

RexxVariableBase *	getRetriever (RexxString *)

RexxObject *	constantExpression ()

RexxObject *	constantLogicalExpression ()

RexxObject *	parenExpression (RexxToken *)

RexxObject *	expression (int)

RexxObject *	subExpression (int)

size_t	argList (RexxToken *, int)

RexxArray *	argArray (RexxToken *, int)

RexxObject *	function (RexxToken , RexxToken , int)

RexxObject *	collectionMessage (RexxToken , RexxObject , int)

RexxToken *	getToken (int, int)

RexxObject *	message (RexxObject *, bool, int)

RexxObject *	messageTerm ()

RexxObject *	variableOrMessageTerm ()

RexxObject *	messageSubterm (int)

RexxObject *	subTerm (int)

void	pushTerm (RexxObject *)

RexxObject *	popTerm ()

RexxObject *	popNTerms (size_t)

void	isExposeValid ()

RexxArray *	words (RexxString *)

void	errorCleanup ()

void	error (int)

void	error (int, RexxObject *)

void	error (int, RexxObject , RexxObject )

void	error (int, RexxObject , RexxObject , RexxObject *)

void	error (int errorcode, SourceLocation &location, RexxArray *subs)

void	errorLine (int, RexxInstruction *)

void	errorPosition (int, RexxToken *)

void	errorToken (int, RexxToken *)

void	blockError (RexxInstruction *)

RexxInstruction *	sourceNewObject (size_t, RexxBehaviour *, int)

size_t	processVariableList (int)

RexxObject *	parseConditional (int *, int)

RexxObject *	parseLogical (RexxToken *first, int terminators)

bool	terminator (int, RexxToken *)

bool	isTraceable ()

bool	isInterpret ()

bool	needsInstallation ()

void	install (RexxActivation *activation)

void	addReference (RexxObject *reference)

void	pushDo (RexxInstruction *i)

RexxInstruction *	popDo ()

RexxInstruction *	topDo ()

void	setProgramName (RexxString *name)

RexxString *	getProgramName ()

RexxString *	getProgramDirectory ()

RexxString *	getProgramExtension ()

RexxString *	getProgramFile ()

RexxDirectory *	getMethods ()

RexxDirectory *	getRoutines ()

void	pushOperator (RexxToken *operatorToken)

RexxToken *	popOperator ()

RexxToken *	topOperator ()

void	reclaimClause ()

bool	atEnd (void)

RexxToken *	nextToken ()

RexxToken *	nextReal ()

void	previousToken ()

void	firstToken ()

void	trimClause ()

size_t	markPosition ()

void	resetPosition (size_t p)

void	syntaxError (int errorcode, RexxInstruction *i)

void	blockSyntaxError (RexxInstruction *i)

void	syntaxErrorAt (int errorcode, RexxToken *token)

void	syntaxError (int errorcode, RexxObject *a1)

void	syntaxError (int errorcode, RexxObject a1, RexxObject a2)

void	syntaxError (int errorcode, RexxObject a1, RexxObject a2, RexxObject *a3)

void	syntaxError (int errorcode, RexxToken *token)

void	syntaxError (int errorcode)

bool	isInternalCode ()

StackFrameClass *	createStackFrame ()

RexxInstruction *	addressNew ()

RexxInstruction *	assignmentNew (RexxToken *)

RexxInstruction *	assignmentOpNew (RexxToken , RexxToken )

RexxInstruction *	callNew ()

RexxInstruction *	commandNew ()

RexxInstruction *	doNew ()

RexxInstruction *	loopNew ()

RexxInstruction *	createLoop ()

RexxInstruction *	createDoLoop ()

RexxInstruction *	createDoLoop (RexxInstructionDo *, bool)

RexxInstruction *	dropNew ()

RexxInstruction *	elseNew (RexxToken *)

RexxInstruction *	endNew ()

RexxInstruction *	endIfNew (RexxInstructionIf *)

RexxInstruction *	exitNew ()

RexxInstruction *	exposeNew ()

RexxInstruction *	forwardNew ()

void	RexxInstructionForwardCreate (RexxInstructionForward *)

RexxInstruction *	guardNew ()

RexxInstruction *	ifNew (int)

RexxInstruction *	instructionNew (int)

RexxInstruction *	interpretNew ()

RexxInstruction *	labelNew ()

RexxInstruction *	leaveNew (int)

RexxInstruction *	messageNew (RexxExpressionMessage *)

RexxInstruction *	messageAssignmentNew (RexxExpressionMessage , RexxObject )

RexxInstruction *	messageAssignmentOpNew (RexxExpressionMessage , RexxToken , RexxObject *)

RexxInstruction *	nopNew ()

RexxInstruction *	numericNew ()

RexxInstruction *	optionsNew ()

RexxInstruction *	otherwiseNew (RexxToken *)

RexxInstruction *	parseNew (int)

RexxInstruction *	procedureNew ()

RexxInstruction *	queueNew (int)

RexxInstruction *	raiseNew ()

RexxInstruction *	replyNew ()

RexxInstruction *	returnNew ()

RexxInstruction *	sayNew ()

RexxInstruction *	selectNew ()

RexxInstruction *	signalNew ()

RexxInstruction *	thenNew (RexxToken , RexxInstructionIf )

RexxInstruction *	traceNew ()

RexxInstruction *	useNew ()

void	holdObject (RexxObject *object)

void	saveObject (RexxObject *object)

void	removeObj (RexxObject *object)

void	setSecurityManager (RexxObject *manager)

SecurityManager *	getSecurityManager ()

RexxDirectory *	getLocalRoutines ()

RexxDirectory *	getPublicRoutines ()

void	setLocalRoutines (RexxDirectory *r)

void	setPublicRoutines (RexxDirectory *r)

void	addInstalledClass (RexxString name, RexxClass classObject, bool publicClass)

void	addInstalledRoutine (RexxString name, RoutineClass routineObject, bool publicRoutine)

RexxDirectory *	getInstalledClasses ()

RexxDirectory *	getInstalledPublicClasses ()

RexxDirectory *	getImportedClasses ()

RexxDirectory *	getInstalledRoutines ()

RexxDirectory *	getInstalledPublicRoutines ()

RexxDirectory *	getImportedRoutines ()

RexxDirectory *	getDefinedMethods ()

RexxList *	getPackages ()

size_t	getDigits ()

bool	getForm ()

size_t	getFuzz ()

size_t	getTraceSetting ()

size_t	getTraceFlags ()

RexxString *	getTrace ()

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

void *	operator new (size_t, RexxClass , RexxObject *, 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 *	copy ()

virtual RexxObject *	evaluate (RexxActivation , RexxExpressionStack )

virtual RexxObject *	getValue (RexxActivation *)

virtual RexxObject *	getValue (RexxVariableDictionary *)

virtual RexxObject *	getRealValue (RexxActivation *)

virtual RexxObject *	getRealValue (RexxVariableDictionary *)

virtual void	uninit ()

virtual HashCode	hash ()

virtual HashCode	getHashValue ()

HashCode	identityHash ()

virtual bool	truthValue (int)

virtual bool	logicalValue (logical_t &)

virtual RexxString *	makeString ()

virtual void	copyIntoTail (RexxCompoundTail *buffer)

virtual RexxString *	primitiveMakeString ()

virtual RexxArray *	makeArray ()

virtual RexxString *	stringValue ()

virtual RexxInteger *	integerValue (size_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)

virtual RexxNumberString *	numberString ()

virtual bool	isEqual (RexxObject *)

virtual bool	isInstanceOf (RexxClass *)

virtual RexxMethod *	instanceMethod (RexxString *)

virtual RexxSupplier *	instanceMethods (RexxClass *)

void	hasUninit ()

void	removedUninit ()

void	printObject ()

RexxObject *	clone ()

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

Static Public Member Functions
static int	resolveKeyword (RexxString token, KeywordEntry Table, int Table_Size)

static int	subKeyword (RexxToken *)

static int	keyword (RexxToken *)

static int	builtin (RexxToken *)

static size_t	resolveBuiltin (RexxString *)

static int	condition (RexxToken *)

static int	parseOption (RexxToken *)

static int	keyDirective (RexxToken *)

static int	subDirective (RexxToken *)

static int	precedence (RexxToken *)

static bool	parseTraceSetting (RexxString *, size_t &, size_t &, char &)

static RexxString *	formatTraceSetting (size_t source)

static bool	isSymbolCharacter (char ch)

static int	translateChar (char ch)

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

Static Public Attributes
static pbuiltin	builtinTable []

static const size_t	TRACE_ALL = 'A'

static const size_t	TRACE_COMMANDS = 'C'

static const size_t	TRACE_LABELS = 'L'

static const size_t	TRACE_NORMAL = 'N'

static const size_t	TRACE_FAILURES = 'F'

static const size_t	TRACE_ERRORS = 'E'

static const size_t	TRACE_RESULTS = 'R'

static const size_t	TRACE_INTERMEDIATES = 'I'

static const size_t	TRACE_OFF = 'O'

static const size_t	TRACE_IGNORE = '0'

static const size_t	DEFAULT_TRACE_SETTING = TRACE_NORMAL

static const size_t	TRACE_SETTING_MASK = 0xff

static const size_t	DEBUG_IGNORE = 0x0000

static const size_t	DEBUG_ON = 0x0100

static const size_t	DEBUG_OFF = 0x0200

static const size_t	DEBUG_TOGGLE = 0x0400

static const size_t	DEBUG_NOTRACE = 0x0800

static const size_t	TRACE_DEBUG_MASK = 0xff00

Protected Attributes
size_t	flags

RexxArray *	sourceArray

RexxString *	programName

RexxString *	programDirectory

RexxString *	programFile

RexxString *	programExtension

SecurityManager *	securityManager

const char *	current

RexxClause *	clause

SourceLocation	clauseLocation

RexxBuffer *	sourceBuffer

RexxBuffer *	sourceIndices

size_t	current_length

size_t	line_count

size_t	line_number

size_t	line_offset

size_t	interpret_adjust

RexxCode *	initCode

RexxList *	loadedPackages

PackageClass *	package

RexxSource *	parentSource

RexxDirectory *	routines

RexxDirectory *	public_routines

RexxList *	libraries

RexxList *	requires

RexxList *	classes

RexxDirectory *	installed_public_classes

RexxDirectory *	installed_classes

RexxDirectory *	merged_public_classes

RexxDirectory *	merged_public_routines

RexxDirectory *	methods

size_t	digits

size_t	fuzz

bool	form

size_t	traceSetting

size_t	traceFlags

intptr_t	reserved1

intptr_t	reserved2

intptr_t	reserved3

intptr_t	reserved4

RexxIdentityTable *	savelist

RexxStack *	holdstack

RexxDirectory *	literals

RexxDirectory *	strings

RexxQueue *	control

RexxQueue *	terms

RexxQueue *	subTerms

RexxQueue *	operators

RexxDirectory *	class_dependencies

ClassDirective *	active_class

RexxInstruction *	first

RexxInstruction *	last

RexxInstruction *	currentInstruction

RexxDirectory *	variables

RexxDirectory *	labels

RexxIdentityTable *	guard_variables

RexxDirectory *	exposed_variables

RexxList *	calls

size_t	currentstack

size_t	maxstack

size_t	variableindex

Static Protected Attributes
static KeywordEntry	directives []

static KeywordEntry	keywordInstructions []

static KeywordEntry	subKeywords []

static KeywordEntry	builtinFunctions []

static KeywordEntry	conditionKeywords []

static KeywordEntry	parseOptions []

static KeywordEntry	subDirectives []

static int	characterTable []

Friends
class	RexxActivation

Additional Inherited Members
Public Attributes inherited from RexxInternalObject
ObjectHeader	header

RexxBehaviour *	behaviour

Protected Member Functions inherited from RexxVirtualBase
virtual	~RexxVirtualBase ()

virtual void	baseVirtual ()

Detailed Description

Definition at line 131 of file SourceFile.hpp.

Constructor & Destructor Documentation

◆ RexxSource() [1/5]

RexxSource::RexxSource	(	RexxString *	programname,
		RexxArray *	source_array
	)

Create a source object with source provided from an array.

Parameters

programname	The name of the program.
source_array	The array of the source lines.

Definition at line 110 of file SourceFile.cpp.

References line_count, OrefSet, position(), setProgramName(), RexxArray::size(), and sourceArray.

Referenced by interpret().

◆ RexxSource() [2/5]

RexxSource::RexxSource	(	RexxString *	programname,
		RexxBuffer *	source_buffer
	)

Create a source object with source provided from a buffer.

Parameters

programname	The name of the program.
source_buffer	The source buffer holding the source data.

Definition at line 130 of file SourceFile.cpp.

References initBuffered(), and setProgramName().

◆ RexxSource() [3/5]

RexxSource::RexxSource	(	RexxString *	programname,
		const char *	data,
		size_t	length
	)

Create a source object with source provided from a a data buffer (not a buffer object).

Parameters

programname	The name of the program.
data	The data buffer pointer.
length	the size of the source buffer.

Definition at line 150 of file SourceFile.cpp.

References initBuffered(), new_buffer(), and setProgramName().

◆ RexxSource() [4/5]

RexxSource::RexxSource ( RexxString * programname )

Create a source object with source provided from a filo.

Parameters

programname The name of the program (also the file name)

Definition at line 167 of file SourceFile.cpp.

References initFile(), and setProgramName().

◆ RexxSource() [5/5]

RexxSource::RexxSource ( RESTORETYPE restoreType )

inline

Definition at line 142 of file SourceFile.hpp.

Member Function Documentation

◆ addBlock()

void RexxSource::addBlock ( void )

◆ addClause()

void RexxSource::addClause ( RexxInstruction * _instruction )

Definition at line 4507 of file SourceFile.cpp.

References first, last, OREF_NULL, OrefSet, RexxInstruction::setNext(), and toss().

Referenced by flushControl(), and translateBlock().

◆ addCompound()

RexxCompoundVariable * RexxSource::addCompound ( RexxString * name )

Definition at line 4249 of file SourceFile.cpp.

References addStem(), addVariable(), commonString(), RexxString::getLength(), RexxString::getStringData(), RexxStemVariable::index, new_string(), RexxQueue::push(), and subTerms.

Referenced by addText().

◆ addInstalledClass()

void RexxSource::addInstalledClass	(	RexxString *	name,
		RexxClass *	classObject,
		bool	publicClass
	)

Add an installed class to this source package

Parameters

name	The class name
classObject	The class object
publicClass	Indicates whether this needs to be added to the public list as well.

Definition at line 6175 of file SourceFile.cpp.

References install(), installed_classes, installed_public_classes, new_directory(), OREF_NULL, OrefSet, and RexxDirectory::setEntry().

Referenced by PackageClass::addClass(), PackageClass::addPublicClass(), and ClassDirective::install().

◆ addInstalledRoutine()

void RexxSource::addInstalledRoutine	(	RexxString *	name,
		RoutineClass *	routineObject,
		bool	publicRoutine
	)

Add an installed routine to this source package

Parameters

name	The routine name
classObject	The routine object
publicClass	Indicates whether this needs to be added to the public list as well.

Definition at line 6206 of file SourceFile.cpp.

References install(), new_directory(), OREF_NULL, OrefSet, public_routines, routines, and RexxDirectory::setEntry().

Referenced by PackageClass::addPublicRoutine(), and PackageClass::addRoutine().

◆ addLabel()

void RexxSource::addLabel	(	RexxInstruction *	label,
		RexxString *	labelname
	)

Definition at line 4533 of file SourceFile.cpp.

References RexxDirectory::fastAt(), labels, OREF_NULL, and RexxDirectory::put().

Referenced by labelNew().

◆ addMethod()

void RexxSource::addMethod	(	RexxString *	name,
		RexxMethod *	method,
		bool	classMethod
	)

Add a new method to this compilation.

Parameters

name	The directory name of the method.
method	The method object.
classMethod	The class/instance method indicator.

Definition at line 2133 of file SourceFile.cpp.

References active_class, ClassDirective::addMethod(), methods, OREF_NULL, and RexxDirectory::setEntry().

Referenced by attributeDirective(), createAbstractMethod(), createAttributeGetterMethod(), createAttributeSetterMethod(), createConstantGetterMethod(), createMethod(), and methodDirective().

◆ addPackage()

void RexxSource::addPackage ( PackageClass * p )

Add a package to a source file context. This allows new packages to be imported into a source.

Parameters

p

Definition at line 6126 of file SourceFile.cpp.

References RexxList::append(), PackageClass::getSourceObject(), RexxList::hasItem(), install(), loadedPackages, mergeRequired(), new_list(), OREF_NULL, and TheTrueObject.

Referenced by PackageClass::addPackage(), and loadRequires().

◆ addReference()

void RexxSource::addReference ( RexxObject * reference )

inline

Definition at line 285 of file SourceFile.hpp.

References RexxList::addLast(), and calls.

Referenced by callNew(), function(), and signalNew().

◆ addressNew()

RexxInstruction * RexxSource::addressNew ( )

Definition at line 110 of file InstructionParser.cpp.

References Error_Invalid_expression_address, expression(), RexxToken::isEndOfClause(), RexxToken::isSymbolOrLiteral(), new_instruction, nextReal(), OREF_NULL, previousToken(), SUBKEY_VALUE, subKeyword(), syntaxError(), TERM_EOC, and RexxToken::value.

Referenced by instruction().

◆ addStem()

RexxStemVariable * RexxSource::addStem ( RexxString * stemName )

Definition at line 4212 of file SourceFile.cpp.

References _interpret, exposed_variables, RexxDirectory::fastAt(), flags, guard_variables, OREF_NULL, RexxIdentityTable::put(), RexxDirectory::put(), variableindex, and variables.

Referenced by addCompound(), and addText().

◆ addText()

RexxObject * RexxSource::addText ( RexxToken * token )

◆ addVariable() [1/2]

RexxVariableBase * RexxSource::addVariable ( RexxString * varname )

Definition at line 4175 of file SourceFile.cpp.

References _interpret, exposed_variables, RexxDirectory::fastAt(), flags, guard_variables, OREF_NULL, RexxIdentityTable::put(), RexxDirectory::put(), variableindex, and variables.

Referenced by addCompound(), addText(), and parseNew().

◆ addVariable() [2/2]

RexxObject * RexxSource::addVariable ( RexxToken * token )

Definition at line 4349 of file SourceFile.cpp.

References addText(), and needVariable().

◆ argArray()

RexxArray * RexxSource::argArray	(	RexxToken *	_first,
		int	terminators
	)

Definition at line 4900 of file SourceFile.cpp.

References argList(), new_array(), RexxQueue::pop(), RexxArray::put(), and subTerms.

◆ argList()

size_t RexxSource::argList	(	RexxToken *	_first,
		int	terminators
	)

Definition at line 4922 of file SourceFile.cpp.

References RexxToken::classId, Error_Unmatched_parenthesis_paren, Error_Unmatched_parenthesis_square, nextReal(), nextToken(), OREF_NULL, RexxQueue::pop(), popNTerms(), previousToken(), RexxQueue::push(), pushTerm(), subExpression(), subTerms, syntaxErrorAt(), TERM_COMMA, TERM_RIGHT, TERM_SQRIGHT, TOKEN_COMMA, TOKEN_RIGHT, and TOKEN_SQRIGHT.

Referenced by argArray(), callNew(), collectionMessage(), function(), message(), parseLogical(), and raiseNew().

◆ assignmentNew()

RexxInstruction * RexxSource::assignmentNew ( RexxToken * target )

Definition at line 164 of file InstructionParser.cpp.

References addText(), Error_Invalid_expression_assign, expression(), needVariable(), new_instruction, OREF_NULL, syntaxError(), and TERM_EOC.

Referenced by instruction().

◆ assignmentOpNew()

RexxInstruction * RexxSource::assignmentOpNew	(	RexxToken *	target,
		RexxToken *	operation
	)

Create a special assignment op of the form "variable (op)= expr".

Parameters

target	The assignment target variable.
operation	The operator token. classId is TOKEN_ASSIGNMENT, the subclass is the type of the operation to perform.

Returns: The constructed instruction object.

Definition at line 194 of file InstructionParser.cpp.

References addText(), Error_Invalid_expression_assign, expression(), needVariable(), new_instruction, OREF_NULL, RexxToken::subclass, syntaxError(), and TERM_EOC.

Referenced by instruction().

◆ atEnd()

bool RexxSource::atEnd ( void )

inline

Definition at line 300 of file SourceFile.hpp.

References flags, line_count, line_number, and reclaimed.

Referenced by translate().

◆ attributeDirective()

void RexxSource::attributeDirective ( )

Process a ::ATTRIBUTE directive in a source file.

Definition at line 2608 of file SourceFile.cpp.

References addMethod(), ATTRIBUTE_BOTH, ATTRIBUTE_GET, ATTRIBUTE_SET, checkDirective(), checkDuplicateMethod(), commonString(), RexxString::concatToCstring(), RexxString::concatWithCstring(), createAbstractMethod(), createAttributeGetterMethod(), createAttributeSetterMethod(), createMethod(), createNativeMethod(), decodeExternalMethod(), DEFAULT_ACCESS_SCOPE, DEFAULT_GUARD, DEFAULT_PROTECTION, Error_Invalid_subkeyword_attribute, Error_Symbol_or_string_attribute, Error_Symbol_or_string_external, Error_Translation_abstract_attribute, Error_Translation_body_error, Error_Translation_duplicate_attribute, Error_Translation_external_attribute, getRetriever(), GUARDED_METHOD, hasBody(), RexxToken::isEndOfClause(), RexxToken::isLiteral(), RexxToken::isSymbol(), RexxToken::isSymbolOrLiteral(), nextReal(), OREF_NULL, PRIVATE_SCOPE, PROTECTED_METHOD, PUBLIC_SCOPE, RexxMethod::setAttributes(), subDirective(), SUBDIRECTIVE_ABSTRACT, SUBDIRECTIVE_CLASS, SUBDIRECTIVE_EXTERNAL, SUBDIRECTIVE_GET, SUBDIRECTIVE_GUARDED, SUBDIRECTIVE_PRIVATE, SUBDIRECTIVE_PROTECTED, SUBDIRECTIVE_PUBLIC, SUBDIRECTIVE_SET, SUBDIRECTIVE_UNGUARDED, SUBDIRECTIVE_UNPROTECTED, syntaxError(), UNGUARDED_METHOD, UNPROTECTED_METHOD, RexxString::upper(), and RexxToken::value.

Referenced by directive().

◆ blockError()

void RexxSource::blockError ( RexxInstruction * _instruction )

Definition at line 5639 of file SourceFile.cpp.

References clauseLocation, Error_Incomplete_do_do, Error_Incomplete_do_else, Error_Incomplete_do_loop, Error_Incomplete_do_otherwise, Error_Incomplete_do_select, Error_Incomplete_do_then, RexxInstruction::getLocation(), RexxInstruction::getType(), KEYWORD_DO, KEYWORD_ELSE, KEYWORD_IF, KEYWORD_IFTHEN, KEYWORD_LOOP, KEYWORD_OTHERWISE, KEYWORD_SELECT, KEYWORD_WHENTHEN, last, and syntaxError().

Referenced by blockSyntaxError().

◆ blockSyntaxError()

void RexxSource::blockSyntaxError ( RexxInstruction * i )

inline

Definition at line 310 of file SourceFile.hpp.

References blockError().

Referenced by translateBlock().

◆ builtin()

int RexxSource::builtin ( RexxToken * token )

static

Definition at line 496 of file KeywordConstants.cpp.

References builtinFunctions, RexxToken::isSymbolOrLiteral(), resolveKeyword(), tabSize, and RexxToken::value.

Referenced by callNew().

◆ callNew()

RexxInstruction * RexxSource::callNew ( )

Definition at line 215 of file InstructionParser.cpp.

References addReference(), argList(), builtin(), RexxInstructionCall::call_dynamic, RexxInstructionCall::call_nointernal, RexxInstructionCall::call_on_off, CHAR_USER_BLANK, RexxToken::classId, commonString(), RexxString::concatToCstring(), condition(), CONDITION_LOSTDIGITS, CONDITION_NOMETHOD, CONDITION_NOSTRING, CONDITION_NOVALUE, CONDITION_PROPAGATE, CONDITION_SYNTAX, CONDITION_USER, Error_Invalid_data_condition, Error_Invalid_data_name, Error_Invalid_expression_call, Error_Invalid_subkeyword_calloff, Error_Invalid_subkeyword_callon, Error_Invalid_subkeyword_callonname, Error_Symbol_expected_off, Error_Symbol_expected_on, Error_Symbol_expected_user, Error_Symbol_or_string_call, Error_Symbol_or_string_name, flags, RexxToken::isEndOfClause(), RexxToken::isLiteral(), RexxToken::isSymbol(), new_variable_instruction, nextReal(), OREF_NULL, parenExpression(), SUBKEY_NAME, SUBKEY_OFF, SUBKEY_ON, subKeyword(), subTerms, syntaxError(), TERM_EOC, TOKEN_LEFT, TOKEN_LITERAL, TOKEN_SYMBOL, and RexxToken::value.

Referenced by instruction().

◆ checkDirective()

void RexxSource::checkDirective ( int errorCode )

Definition at line 1247 of file SourceFile.cpp.

References RexxToken::classId, clauseLocation, firstToken(), flags, nextClause(), nextReal(), no_clause, reclaimClause(), syntaxError(), and TOKEN_DCOLON.

Referenced by attributeDirective(), constantDirective(), methodDirective(), and routineDirective().

◆ checkDuplicateMethod()

void RexxSource::checkDuplicateMethod	(	RexxString *	name,
		bool	classMethod,
		int	errorMsg
	)

check for a duplicate method.

Parameters

name	The name to check.
classMethod	Indicates whether this is a check for a CLASS or INSTANCE method.
errorMsg	The error code to use if there is a duplicate.

Definition at line 2097 of file SourceFile.cpp.

References active_class, ClassDirective::checkDuplicateMethod(), RexxDirectory::entry(), Error_Translation_missing_class, methods, OREF_NULL, and syntaxError().

Referenced by attributeDirective(), constantDirective(), and methodDirective().

◆ classDirective()

void RexxSource::classDirective ( )

Process a ::CLASS directive for a source file.

Definition at line 1932 of file SourceFile.cpp.

References _install, active_class, RexxList::append(), class_dependencies, classes, clause, commonString(), DEFAULT_ACCESS_SCOPE, RexxDirectory::entry(), Error_Invalid_subkeyword_class, Error_Symbol_or_string_class, Error_Symbol_or_string_inherit, Error_Symbol_or_string_metaclass, Error_Symbol_or_string_mixinclass, Error_Symbol_or_string_subclass, Error_Translation_duplicate_class, flags, ClassDirective::getMetaClass(), ClassDirective::getSubClass(), RexxToken::isEndOfClause(), RexxToken::isSymbol(), RexxToken::isSymbolOrLiteral(), nextReal(), OREF_NULL, OrefSet, previousToken(), PRIVATE_SCOPE, PUBLIC_SCOPE, RexxDirectory::put(), subDirective(), SUBDIRECTIVE_INHERIT, SUBDIRECTIVE_METACLASS, SUBDIRECTIVE_MIXINCLASS, SUBDIRECTIVE_PRIVATE, SUBDIRECTIVE_PUBLIC, SUBDIRECTIVE_SUBCLASS, syntaxError(), type, RexxString::upper(), and RexxToken::value.

Referenced by directive().

◆ cleanup()

void RexxSource::cleanup ( )

Definition at line 1320 of file SourceFile.cpp.

References active_class, calls, class_dependencies, clause, control, currentInstruction, exposed_variables, first, guard_variables, holdstack, labels, last, literals, operators, OREF_NULL, OrefSet, savelist, strings, subTerms, terms, and variables.

Referenced by errorCleanup(), generateCode(), and interpretMethod().

◆ collectionMessage()

RexxObject * RexxSource::collectionMessage	(	RexxToken *	token,
		RexxObject *	target,
		int	terminators
	)

Definition at line 5005 of file SourceFile.cpp.

References argList(), holdObject(), OREF_NULL, removeObj(), saveObject(), subTerms, TERM_RIGHT, and TERM_SQRIGHT.

Referenced by messageSubterm(), messageTerm(), and subExpression().

◆ commandNew()

RexxInstruction * RexxSource::commandNew ( )

Definition at line 430 of file InstructionParser.cpp.

References expression(), new_instruction, and TERM_EOC.

Referenced by instruction().

◆ comment()

void RexxSource::comment ( )

Definition at line 227 of file Scanner.cpp.

References clause, clauseLocation, current_length, Error_Unmatched_quote_comment, GETCHAR, RexxClause::getLocation(), line_count, line_number, line_offset, new_integer(), nextLine(), RexxClause::setEnd(), and syntaxError().

Referenced by locateToken().

◆ commonString()

RexxString * RexxSource::commonString ( RexxString * string )

Definition at line 4330 of file SourceFile.cpp.

References RexxDirectory::fastAt(), OREF_NULL, RexxDirectory::put(), and strings.

Referenced by addCompound(), addText(), attributeDirective(), callNew(), classDirective(), constantDirective(), RexxExpressionMessage::makeAssignment(), methodDirective(), packLiteral(), raiseNew(), signalNew(), sourceNextToken(), and words().

◆ condition()

int RexxSource::condition ( RexxToken * token )

static

Definition at line 521 of file KeywordConstants.cpp.

References conditionKeywords, RexxToken::isSymbol(), resolveKeyword(), tabSize, and RexxToken::value.

Referenced by callNew(), raiseNew(), RexxActivation::setConditionObj(), and signalNew().

◆ constantDirective()

void RexxSource::constantDirective ( )

Process a CONSTANT directive in a source file.

Definition at line 2922 of file SourceFile.cpp.

References active_class, checkDirective(), checkDuplicateMethod(), commonString(), createConstantGetterMethod(), Error_Invalid_data_constant_dir, Error_Symbol_or_string_constant, Error_Symbol_or_string_constant_value, Error_Translation_constant_body, Error_Translation_duplicate_constant, RexxToken::isSymbol(), RexxToken::isSymbolOrLiteral(), nextReal(), RexxObject::numberString(), OPERATOR_PLUS, OPERATOR_SUBTRACT, OREF_NULL, RexxToken::subclass, SYMBOL_CONSTANT, syntaxError(), RexxString::upper(), and RexxToken::value.

Referenced by directive().

◆ constantExpression()

RexxObject * RexxSource::constantExpression ( )

Definition at line 4593 of file SourceFile.cpp.

References addText(), RexxToken::classId, Error_Invalid_expression_general, Error_Unmatched_parenthesis_paren, holdObject(), RexxToken::isConstant(), RexxToken::isEndOfClause(), RexxToken::isLiteral(), nextReal(), nextToken(), OREF_NULL, previousToken(), subExpression(), syntaxError(), syntaxErrorAt(), TERM_EOC, TERM_RIGHT, TOKEN_LEFT, and TOKEN_RIGHT.

Referenced by raiseNew(), and useNew().

◆ constantLogicalExpression()

RexxObject * RexxSource::constantLogicalExpression ( )

Definition at line 4641 of file SourceFile.cpp.

References addText(), RexxToken::classId, Error_Invalid_expression_general, Error_Unmatched_parenthesis_paren, holdObject(), RexxToken::isConstant(), RexxToken::isEndOfClause(), RexxToken::isLiteral(), nextReal(), nextToken(), OREF_NULL, parseLogical(), previousToken(), syntaxError(), syntaxErrorAt(), TERM_EOC, TERM_RIGHT, TOKEN_LEFT, and TOKEN_RIGHT.

◆ createAbstractMethod()

void RexxSource::createAbstractMethod	(	RexxString *	name,
		bool	classMethod,
		bool	privateMethod,
		bool	protectedMethod,
		bool	guardedMethod
	)

Create an abstract method.

Parameters

name	The name of the method.
classMethod	Indicates we're adding a class or instance method.
privateMethod	The method's private attribute.
protectedMethod	The method's protected attribute.
guardedMethod	The method's guarded attribute.

Definition at line 3090 of file SourceFile.cpp.

References addMethod(), and RexxMethod::setAttributes().

Referenced by attributeDirective().

◆ createAttributeGetterMethod()

void RexxSource::createAttributeGetterMethod	(	RexxString *	name,
		RexxVariableBase *	retriever,
		bool	classMethod,
		bool	privateMethod,
		bool	protectedMethod,
		bool	guardedMethod
	)

Create an ATTRIBUTE "get" method.

Parameters

name	The name of the attribute.
retriever
classMethod	Indicates we're adding a class or instance method.
privateMethod	The method's private attribute.
protectedMethod	The method's protected attribute.
guardedMethod	The method's guarded attribute.

Definition at line 3040 of file SourceFile.cpp.

References addMethod(), and RexxMethod::setAttributes().

Referenced by attributeDirective(), and methodDirective().

◆ createAttributeSetterMethod()

void RexxSource::createAttributeSetterMethod	(	RexxString *	name,
		RexxVariableBase *	retriever,
		bool	classMethod,
		bool	privateMethod,
		bool	protectedMethod,
		bool	guardedMethod
	)

Create an ATTRIBUTE "set" method.

Parameters

name	The name of the attribute.
classMethod	Indicates we're adding a class or instance method.
privateMethod	The method's private attribute.
protectedMethod	The method's protected attribute.
guardedMethod	The method's guarded attribute.

Definition at line 3065 of file SourceFile.cpp.

References addMethod(), and RexxMethod::setAttributes().

Referenced by attributeDirective(), and methodDirective().

◆ createConstantGetterMethod()

void RexxSource::createConstantGetterMethod	(	RexxString *	name,
		RexxObject *	value
	)

Create a CONSTANT "get" method.

Parameters

target	The target method directory.
name	The name of the attribute.

Definition at line 3109 of file SourceFile.cpp.

References active_class, ClassDirective::addConstantMethod(), addMethod(), OREF_NULL, and RexxMethod::setUnguarded().

Referenced by constantDirective().

◆ createDoLoop() [1/2]

RexxInstruction * RexxSource::createDoLoop ( )

Create a DO instruction instance.

Returns

Definition at line 470 of file InstructionParser.cpp.

References new_instruction.

Referenced by doNew(), and loopNew().

◆ createDoLoop() [2/2]

RexxInstruction * RexxSource::createDoLoop	(	RexxInstructionDo *	newDo,
		bool	isLoop
	)

Definition at line 493 of file InstructionParser.cpp.

◆ createLoop()

RexxInstruction * RexxSource::createLoop ( )

Create a LOOP instruction instance.

Returns

Definition at line 484 of file InstructionParser.cpp.

References new_instruction.

Referenced by loopNew().

◆ createMethod()

void RexxSource::createMethod	(	RexxString *	name,
		bool	classMethod,
		bool	privateMethod,
		bool	protectedMethod,
		bool	guardedMethod
	)

Create a Rexx method body.

Parameters

name	The name of the attribute.
classMethod	Indicates whether we are creating a class or instance method.
privateMethod	The method's private attribute.
protectedMethod	The method's protected attribute.
guardedMethod	The method's guarded attribute.

Definition at line 3006 of file SourceFile.cpp.

References addMethod(), OREF_NULL, saveObject(), RexxMethod::setAttributes(), and translateBlock().

Referenced by attributeDirective().

◆ createNativeMethod()

RexxMethod * RexxSource::createNativeMethod	(	RexxString *	name,
		RexxString *	library,
		RexxString *	procedure
	)

Create a native method from a specification.

Parameters

name	The method name.
library	The library containing the method.
procedure	The name of the procedure within the package.

Returns: A method object representing this method.

Definition at line 2542 of file SourceFile.cpp.

References Error_External_name_not_found_method, OREF_NULL, PackageManager::resolveMethod(), RexxNativeCode::setSourceObject(), and syntaxError().

Referenced by attributeDirective(), and methodDirective().

◆ createStackFrame()

StackFrameClass * RexxSource::createStackFrame ( )

Create a stack frame for this parsing context.

Returns: a stack frame instance for error reporting

Definition at line 924 of file SourceFile.cpp.

References clauseLocation, FRAME_PARSE, SourceLocation::getLineNumber(), OREF_NULL, programName, and traceBack().

Referenced by ParseActivationFrame::createStackFrame().

◆ decodeExternalMethod()

void RexxSource::decodeExternalMethod	(	RexxString *	methodName,
		RexxString *	externalSpec,
		RexxString *&	library,
		RexxString *&	procedure
	)

Decode an external library method specification.

Parameters

methodName	The internal name of the method (uppercased).
externalSpec	The external specification string.
library	The returned library name.
procedure	The returned package name.

Definition at line 2566 of file SourceFile.cpp.

References CHAR_LIBRARY, Error_Translation_bad_external, RexxArray::get(), OREF_NULL, RexxArray::size(), syntaxError(), and words().

Referenced by attributeDirective(), and methodDirective().

◆ directive()

void RexxSource::directive ( )

◆ doNew()

RexxInstruction * RexxSource::doNew ( )

Definition at line 444 of file InstructionParser.cpp.

References createDoLoop().

Referenced by instruction().

◆ dropNew()

RexxInstruction * RexxSource::dropNew ( )

Definition at line 783 of file InstructionParser.cpp.

References KEYWORD_DROP, new_variable_instruction, processVariableList(), and subTerms.

Referenced by instruction().

◆ elseNew()

RexxInstruction * RexxSource::elseNew ( RexxToken * token )

Definition at line 797 of file InstructionParser.cpp.

References new_instruction.

Referenced by instruction().

◆ endIfNew()

RexxInstruction * RexxSource::endIfNew ( RexxInstructionIf * parent )

Definition at line 839 of file InstructionParser.cpp.

References new_instruction.

Referenced by flushControl().

◆ endLocation()

void RexxSource::endLocation ( SourceLocation & location )

Definition at line 196 of file Scanner.cpp.

References line_number, line_offset, and SourceLocation::setEnd().

Referenced by nextSpecial(), and sourceNextToken().

◆ endNew()

RexxInstruction * RexxSource::endNew ( )

Definition at line 810 of file InstructionParser.cpp.

References Error_Invalid_data_end, Error_Symbol_expected_end, RexxToken::isEndOfClause(), RexxToken::isSymbol(), new_instruction, nextReal(), OREF_NULL, syntaxError(), and RexxToken::value.

Referenced by instruction().

◆ error() [1/5]

void RexxSource::error	(	int	errorcode,
		SourceLocation &	location,
		RexxArray *	subs
	)

Definition at line 5493 of file SourceFile.cpp.

References clauseLocation, ActivityManager::currentActivity, errorCleanup(), OREF_NULL, and RexxActivity::raiseException().

◆ error() [2/5]

void RexxSource::error ( int errorcode )

Definition at line 5483 of file SourceFile.cpp.

References ActivityManager::currentActivity, errorCleanup(), OREF_NULL, and RexxActivity::raiseException().

Referenced by RexxInstructionSelect::matchEnd(), RexxInstructionDo::matchLabel(), and syntaxError().

◆ error() [3/5]

void RexxSource::error	(	int	errorcode,
		RexxObject *	value
	)

Definition at line 5600 of file SourceFile.cpp.

References ActivityManager::currentActivity, errorCleanup(), new_array(), OREF_NULL, and RexxActivity::raiseException().

◆ error() [4/5]

void RexxSource::error	(	int	errorcode,
		RexxObject *	value1,
		RexxObject *	value2
	)

Definition at line 5612 of file SourceFile.cpp.

References ActivityManager::currentActivity, errorCleanup(), new_array(), OREF_NULL, and RexxActivity::raiseException().

◆ error() [5/5]

void RexxSource::error	(	int	errorcode,
		RexxObject *	value1,
		RexxObject *	value2,
		RexxObject *	value3
	)

Definition at line 5625 of file SourceFile.cpp.

References ActivityManager::currentActivity, errorCleanup(), new_array(), OREF_NULL, and RexxActivity::raiseException().

◆ errorCleanup()

void RexxSource::errorCleanup ( )

Definition at line 5475 of file SourceFile.cpp.

References cleanup().

Referenced by error(), errorLine(), errorPosition(), and errorToken().

◆ errorLine()

void RexxSource::errorLine	(	int	errorcode,
		RexxInstruction *	_instruction
	)

Definition at line 5504 of file SourceFile.cpp.

References ActivityManager::currentActivity, errorCleanup(), RexxInstruction::getLineNumber(), new_array(), new_integer(), OREF_NULL, and RexxActivity::raiseException().

Referenced by syntaxError().

◆ errorPosition()

void RexxSource::errorPosition	(	int	errorcode,
		RexxToken *	token
	)

Definition at line 5517 of file SourceFile.cpp.

References ActivityManager::currentActivity, errorCleanup(), SourceLocation::getLineNumber(), RexxToken::getLocation(), SourceLocation::getOffset(), new_array(), new_integer(), OREF_NULL, and RexxActivity::raiseException().

Referenced by syntaxErrorAt().

◆ errorToken()

void RexxSource::errorToken	(	int	errorcode,
		RexxToken *	token
	)

Definition at line 5531 of file SourceFile.cpp.

References RexxToken::classId, ActivityManager::currentActivity, errorCleanup(), new_array(), new_string(), OREF_NULL, RexxActivity::raiseException(), TOKEN_BLANK, TOKEN_COLON, TOKEN_COMMA, TOKEN_DCOLON, TOKEN_DTILDE, TOKEN_EOC, TOKEN_LEFT, TOKEN_RIGHT, TOKEN_SQLEFT, TOKEN_SQRIGHT, TOKEN_TILDE, and RexxToken::value.

Referenced by syntaxError().

◆ exitNew()

RexxInstruction * RexxSource::exitNew ( )

Definition at line 852 of file InstructionParser.cpp.

References expression(), new_instruction, and TERM_EOC.

Referenced by instruction().

◆ expose()

void RexxSource::expose ( RexxString * name )

Definition at line 4318 of file SourceFile.cpp.

References exposed_variables, and RexxDirectory::put().

Referenced by processVariableList().

◆ exposeNew()

RexxInstruction * RexxSource::exposeNew ( )

Definition at line 866 of file InstructionParser.cpp.

References isExposeValid(), KEYWORD_EXPOSE, new_variable_instruction, processVariableList(), and subTerms.

Referenced by instruction().

◆ expression()

RexxObject * RexxSource::expression ( int terminators )

Definition at line 4712 of file SourceFile.cpp.

References nextReal(), previousToken(), and subExpression().

Referenced by addressNew(), assignmentNew(), assignmentOpNew(), commandNew(), exitNew(), guardNew(), interpretNew(), numericNew(), optionsNew(), parseNew(), queueNew(), replyNew(), returnNew(), sayNew(), signalNew(), and traceNew().

◆ extract()

RexxString * RexxSource::extract ( SourceLocation & location )

Definition at line 1017 of file SourceFile.cpp.

References RexxString::extract(), get(), SourceLocation::getEndLine(), SourceLocation::getEndOffset(), RexxString::getLength(), SourceLocation::getLineNumber(), SourceLocation::getOffset(), interpret_adjust, line, line_count, OREF_NULL, reconnect(), sourceArray, and sourceBuffer.

Referenced by RexxCode::extract(), and traceBack().

◆ extractNameInformation()

void RexxSource::extractNameInformation ( )

Extract various bits of the source name to give us directory, extension and file portions to be used for searches for additional files.

Definition at line 315 of file SourceFile.cpp.

References SysFileSystem::extractDirectory(), SysFileSystem::extractExtension(), SysFileSystem::extractFile(), OREF_NULL, OrefSet, programDirectory, programExtension, programFile, and programName.

Referenced by initBuffered(), and setProgramName().

◆ extractSource() [1/2]

RexxArray * RexxSource::extractSource ( )

Extract all of the source from the package.

Returns: An array of the source lines.

Definition at line 1066 of file SourceFile.cpp.

References SourceLocation::setEndLine(), SourceLocation::setLineNumber(), and SourceLocation::setOffset().

◆ extractSource() [2/2]

RexxArray * RexxSource::extractSource ( SourceLocation & location )

Definition at line 1079 of file SourceFile.cpp.

References RexxString::extract(), get(), SourceLocation::getEndLine(), SourceLocation::getEndOffset(), RexxString::getLength(), SourceLocation::getLineNumber(), SourceLocation::getOffset(), interpret_adjust, line_count, new_array(), OREF_NULL, RexxArray::put(), reconnect(), SourceLocation::setEnd(), SourceLocation::setEndLine(), SourceLocation::setEndOffset(), sourceArray, sourceBuffer, and TheNullArray.

Referenced by PackageClass::getSource(), and RexxCode::getSource().

◆ findClass()

RexxClass * RexxSource::findClass ( RexxString * className )

Resolve a class from this source file context (including any chained parent contexts).

Parameters

className The target name of the class.

Returns: The resolved class object, if any.

Definition at line 1609 of file SourceFile.cpp.

References SecurityManager::checkEnvironmentAccess(), SecurityManager::checkLocalAccess(), findInstalledClass(), findPublicClass(), ActivityManager::getLocalEnvironment(), OREF_NULL, securityManager, TheEnvironment, and RexxString::upper().

Referenced by RexxNativeCode::findClass(), PackageClass::findClass(), RexxActivation::findClass(), PackageClass::findClassRexx(), ClassDirective::install(), and RexxActivation::resolveDotVariable().

◆ findInstalledClass()

RexxClass * RexxSource::findInstalledClass ( RexxString * name )

Resolve a directly defined class object in this or a parent context.

Parameters

name	The name we're searching for (all uppercase).

Returns: A resolved class object, if found.

Definition at line 1555 of file SourceFile.cpp.

References RexxDirectory::fastAt(), findInstalledClass(), installed_classes, OREF_NULL, and parentSource.

Referenced by findClass(), and findInstalledClass().

◆ findLabel()

RexxInstruction * RexxSource::findLabel ( RexxString * labelname )

Definition at line 4549 of file SourceFile.cpp.

References RexxDirectory::fastAt(), labels, and OREF_NULL.

◆ findLocalRoutine()

RoutineClass * RexxSource::findLocalRoutine ( RexxString * name )

Resolve a directly defined class object in this or a parent context.

Parameters

name	The name we're searching for (all uppercase).

Returns: A resolved class object, if found.

Definition at line 1451 of file SourceFile.cpp.

References RexxDirectory::fastAt(), findLocalRoutine(), OREF_NULL, parentSource, and routines.

Referenced by findLocalRoutine(), and findRoutine().

◆ findPublicClass()

RexxClass * RexxSource::findPublicClass ( RexxString * name )

Definition at line 1578 of file SourceFile.cpp.

References RexxDirectory::fastAt(), findPublicClass(), merged_public_classes, OREF_NULL, and parentSource.

Referenced by findClass(), and findPublicClass().

◆ findPublicRoutine()

RoutineClass * RexxSource::findPublicRoutine ( RexxString * name )

Resolve a public routine in this source context

Parameters

name	The target name.

Returns: A resolved Routine object, if found.

Definition at line 1481 of file SourceFile.cpp.

References RexxDirectory::fastAt(), findPublicRoutine(), merged_public_routines, OREF_NULL, and parentSource.

Referenced by findPublicRoutine(), and findRoutine().

◆ findRoutine()

RoutineClass * RexxSource::findRoutine ( RexxString * routineName )

Resolve a routine from this source files base context.

Parameters

routineName The routine name of interest.

Returns: A RoutineClass instance if located. Returns OREF_NULL if this is not known at this level.

Definition at line 1513 of file SourceFile.cpp.

References findLocalRoutine(), findPublicRoutine(), OREF_NULL, and RexxString::upper().

Referenced by PackageClass::findRoutine(), and RexxCode::findRoutine().

◆ firstToken()

void RexxSource::firstToken ( )

inline

Definition at line 305 of file SourceFile.hpp.

References clause, and RexxClause::firstToken().

Referenced by checkDirective(), hasBody(), and instruction().

◆ flatten()

void RexxSource::flatten ( RexxEnvelope * envelope )

virtual

Reimplemented from RexxVirtualBase.

Definition at line 701 of file SourceFile.cpp.

References cleanUpFlatten, flatten_reference, OREF_NULL, securityManager, setUpFlatten, sourceArray, sourceBuffer, and sourceIndices.

◆ flushControl()

void RexxSource::flushControl ( RexxInstruction * _instruction )

Definition at line 3443 of file SourceFile.cpp.

References addClause(), endIfNew(), RexxInstruction::getType(), KEYWORD_ELSE, KEYWORD_IFTHEN, KEYWORD_WHENTHEN, OREF_NULL, popDo(), pushDo(), topDo(), and type.

Referenced by translateBlock().

◆ formatTraceSetting()

RexxString * RexxSource::formatTraceSetting ( size_t source )

static

Format an encoded trace setting back into human readable form.

Parameters

setting The source setting.

Returns: The string representation of the trace setting.

Definition at line 5821 of file SourceFile.cpp.

References DEBUG_ON, new_string(), and TRACE_SETTING_MASK.

Referenced by getTrace(), and RexxActivation::traceSetting().

◆ forwardNew()

RexxInstruction * RexxSource::forwardNew ( )

Definition at line 1006 of file InstructionParser.cpp.

References new_instruction, and RexxInstructionForwardCreate().

Referenced by instruction().

◆ function()

RexxObject * RexxSource::function	(	RexxToken *	token,
		RexxToken *	name,
		int	terminators
	)

Definition at line 4981 of file SourceFile.cpp.

References addReference(), argList(), removeObj(), saveObject(), TERM_RIGHT, and TERM_SQRIGHT.

◆ generateCode()

RexxCode * RexxSource::generateCode ( bool isMethod )

Definition at line 1198 of file SourceFile.cpp.

References cleanup(), globalSetup(), install(), OREF_NULL, and translate().

Referenced by RexxMethod::RexxMethod(), and RoutineClass::RoutineClass().

◆ get()

RexxString * RexxSource::get ( size_t _position )

Definition at line 794 of file SourceFile.cpp.

References RexxArray::get(), RexxBuffer::getData(), isOfClass, line_count, new_string(), OREF_NULL, position(), sourceArray, sourceBuffer, and sourceIndices.

Referenced by builtin_function_SOURCELINE(), extract(), extractSource(), PackageClass::getSourceLine(), and PackageClass::getSourceLineRexx().

◆ getDefinedMethods()

RexxDirectory* RexxSource::getDefinedMethods ( )

inline

Definition at line 397 of file SourceFile.hpp.

References install(), and methods.

◆ getDigits()

size_t RexxSource::getDigits ( )

inline

Definition at line 399 of file SourceFile.hpp.

References digits.

Referenced by PackageClass::digits(), RexxActivation::RexxActivation(), and RexxActivation::setDigits().

◆ getForm()

bool RexxSource::getForm ( )

inline

Definition at line 400 of file SourceFile.hpp.

References form.

Referenced by PackageClass::form(), RexxActivation::RexxActivation(), and RexxActivation::setForm().

◆ getFuzz()

size_t RexxSource::getFuzz ( )

inline

Definition at line 401 of file SourceFile.hpp.

References fuzz.

Referenced by PackageClass::fuzz(), RexxActivation::RexxActivation(), and RexxActivation::setFuzz().

◆ getGuard()

RexxArray * RexxSource::getGuard ( )

Definition at line 4579 of file SourceFile.cpp.

References guard_variables, RexxHashTableCollection::makeArray(), OREF_NULL, and OrefSet.

Referenced by guardNew().

◆ getImportedClasses()

RexxDirectory* RexxSource::getImportedClasses ( )

inline

Definition at line 393 of file SourceFile.hpp.

References install(), and merged_public_classes.

Referenced by PackageClass::getImportedClasses().

◆ getImportedRoutines()

RexxDirectory* RexxSource::getImportedRoutines ( )

inline

Definition at line 396 of file SourceFile.hpp.

References install(), and merged_public_routines.

Referenced by PackageClass::getImportedRoutines().

◆ getInstalledClasses()

RexxDirectory* RexxSource::getInstalledClasses ( )

inline

Definition at line 391 of file SourceFile.hpp.

References install(), and installed_classes.

Referenced by PackageClass::getClasses().

◆ getInstalledPublicClasses()

RexxDirectory* RexxSource::getInstalledPublicClasses ( )

inline

Definition at line 392 of file SourceFile.hpp.

References install(), and installed_public_classes.

Referenced by PackageClass::getPublicClasses().

◆ getInstalledPublicRoutines()

RexxDirectory* RexxSource::getInstalledPublicRoutines ( )

inline

Definition at line 395 of file SourceFile.hpp.

References install(), and public_routines.

Referenced by PackageClass::getPublicRoutines().

◆ getInstalledRoutines()

RexxDirectory* RexxSource::getInstalledRoutines ( )

inline

Definition at line 394 of file SourceFile.hpp.

References install(), and routines.

Referenced by PackageClass::getRoutines().

◆ getLocalRoutines()

RexxDirectory* RexxSource::getLocalRoutines ( )

inline

Definition at line 369 of file SourceFile.hpp.

References routines.

Referenced by RexxCode::getLocalRoutines().

◆ getMethods()

RexxDirectory* RexxSource::getMethods ( )

inline

Definition at line 294 of file SourceFile.hpp.

References methods.

Referenced by PackageClass::getMethods(), and RexxCode::getMethods().

◆ getPackage()

PackageClass * RexxSource::getPackage ( )

Retrieve the package wrapper associated with this source.

Returns: The package instance that fronts for this source in Rexx code.

Definition at line 6156 of file SourceFile.cpp.

References OREF_NULL, OrefSet, and package.

Referenced by RexxActivity::generateProgramInformation(), and RexxActivity::reraiseException().

◆ getPackages()

RexxList* RexxSource::getPackages ( )

inline

Definition at line 398 of file SourceFile.hpp.

References install(), and loadedPackages.

Referenced by PackageClass::getImportedPackages().

◆ getProgramDirectory()

RexxString* RexxSource::getProgramDirectory ( )

inline

Definition at line 291 of file SourceFile.hpp.

References programDirectory.

◆ getProgramExtension()

RexxString* RexxSource::getProgramExtension ( )

inline

Definition at line 292 of file SourceFile.hpp.

References programExtension.

◆ getProgramFile()

RexxString* RexxSource::getProgramFile ( )

inline

Definition at line 293 of file SourceFile.hpp.

References programFile.

◆ getProgramName()

RexxString* RexxSource::getProgramName ( )

inline

Definition at line 290 of file SourceFile.hpp.

References programName.

Referenced by RexxActivity::generateProgramInformation(), PackageClass::getName(), RexxCode::getProgramName(), and RexxActivity::reraiseException().

◆ getPublicRoutines()

RexxDirectory* RexxSource::getPublicRoutines ( )

inline

Definition at line 370 of file SourceFile.hpp.

References public_routines.

Referenced by RexxCode::getPublicRoutines().

◆ getRetriever()

RexxVariableBase * RexxSource::getRetriever ( RexxString * name )

Definition at line 4472 of file SourceFile.cpp.

References RexxVariableDictionary::buildCompoundVariable(), Error_Translation_invalid_attribute, RexxString::isSymbol(), OREF_NULL, STRING_COMPOUND_NAME, STRING_NAME, STRING_STEM, and syntaxError().

Referenced by attributeDirective(), and methodDirective().

◆ getRoutines()

RexxDirectory* RexxSource::getRoutines ( )

inline

Definition at line 295 of file SourceFile.hpp.

References routines.

Referenced by RexxCode::getRoutines().

◆ getSecurityManager()

SecurityManager* RexxSource::getSecurityManager ( )

inline

Definition at line 367 of file SourceFile.hpp.

References securityManager.

Referenced by RexxNativeCode::getSecurityManager(), RexxCode::getSecurityManager(), and RexxNativeActivation::getSecurityManager().

◆ getToken()

RexxToken * RexxSource::getToken	(	int	terminators,
		int	errorcode
	)

Definition at line 5026 of file SourceFile.cpp.

References nextToken(), OREF_NULL, syntaxError(), and terminator().

Referenced by message().

◆ getTrace()

RexxString* RexxSource::getTrace ( )

inline

Definition at line 404 of file SourceFile.hpp.

References formatTraceSetting(), and traceSetting.

Referenced by PackageClass::trace().

◆ getTraceFlags()

size_t RexxSource::getTraceFlags ( )

inline

Definition at line 403 of file SourceFile.hpp.

References traceFlags.

Referenced by RexxActivation::RexxActivation().

◆ getTraceSetting()

size_t RexxSource::getTraceSetting ( )

inline

Definition at line 402 of file SourceFile.hpp.

References traceSetting.

Referenced by RexxActivation::RexxActivation().

◆ globalSetup()

void RexxSource::globalSetup ( )

Definition at line 1170 of file SourceFile.cpp.

References clause, control, RexxMemory::getGlobalStrings(), HOLDSIZE, holdstack, literals, memoryObject, new_directory(), new_identity_table(), new_queue(), operators, OREF_NULL, OrefSet, savelist, strings, subTerms, and terms.

Referenced by generateCode(), and interpretMethod().

◆ guardNew()

RexxInstruction * RexxSource::guardNew ( )

Definition at line 1018 of file InstructionParser.cpp.

References Error_Invalid_expression_guard, Error_Invalid_subkeyword_guard, Error_Invalid_subkeyword_guard_on, Error_Symbol_expected_numeric, expression(), getGuard(), RexxToken::isEndOfClause(), RexxToken::isSymbol(), new_variable_instruction, nextReal(), OREF_NULL, setGuard(), RexxArray::size(), SUBKEY_OFF, SUBKEY_ON, SUBKEY_WHEN, subKeyword(), syntaxError(), and TERM_EOC.

Referenced by instruction().

◆ hasBody()

bool RexxSource::hasBody ( )

Test if a directive is followed by a body of Rexx code instead of another directive or the end of the source.

Returns: True if there is a non-directive clause following the current clause.

Definition at line 1284 of file SourceFile.cpp.

References RexxToken::classId, firstToken(), flags, nextClause(), nextReal(), no_clause, reclaimClause(), and TOKEN_DCOLON.

Referenced by attributeDirective().

◆ holdObject()

void RexxSource::holdObject ( RexxObject * object )

inline

Definition at line 363 of file SourceFile.hpp.

References holdstack, and RexxStack::push().

Referenced by collectionMessage(), constantExpression(), constantLogicalExpression(), message(), messageSubterm(), messageTerm(), parenExpression(), popNTerms(), popTerm(), and toss().

◆ ifNew()

RexxInstruction * RexxSource::ifNew ( int type )

Definition at line 1094 of file InstructionParser.cpp.

References Error_Invalid_expression_if, Error_Invalid_expression_when, KEYWORD_IF, new_instruction, nextReal(), OREF_NULL, parseLogical(), previousToken(), RexxInstruction::setType(), syntaxError(), TERM_IF, and type.

Referenced by instruction().

◆ inheritSourceContext()

void RexxSource::inheritSourceContext ( RexxSource * source )

Merge a parent source context into our context so all of the bits that are visible in the parent are also resolvable in our context. This is mostly used for dynamically created methods.

Parameters

parent The parent source context.

Definition at line 1358 of file SourceFile.cpp.

References OrefSet, and parentSource.

Referenced by RexxMethod::newMethodObject(), and RoutineClass::newRoutineObject().

◆ initBuffered()

void RexxSource::initBuffered ( RexxBuffer * source_buffer )

Definition at line 178 of file SourceFile.cpp.

References RexxSmartBuffer::copyData(), ctrl_z, extractNameInformation(), RexxSmartBuffer::getBuffer(), RexxBuffer::getData(), RexxBufferBase::getDataLength(), _LINE_DESCRIPTOR::length, line_count, line_delimiters, Utilities::locateCharacter(), OREF_NULL, OrefSet, _LINE_DESCRIPTOR::position, position(), sourceBuffer, and sourceIndices.

Referenced by initFile(), RexxSource(), and setBufferedSource().

◆ initFile()

void RexxSource::initFile ( )

Definition at line 272 of file SourceFile.cpp.

References Error_Program_unreadable_name, RexxBuffer::getData(), RexxBufferBase::getDataLength(), RexxString::getStringData(), initBuffered(), OREF_NULL, OrefSet, programName, SystemInterpreter::readProgram(), reportException(), sourceBuffer, and Utilities::strCaselessCompare().

Referenced by reconnect(), and RexxSource().

◆ install() [1/2]

void RexxSource::install ( )

Perform a non-contextual install of a package.

Definition at line 1662 of file SourceFile.cpp.

References RoutineClass::call(), ActivityManager::currentActivity, FIRST_VARIABLE_INDEX, needsInstallation(), OREF_NULL, and programName.

Referenced by addInstalledClass(), addInstalledRoutine(), addPackage(), generateCode(), getDefinedMethods(), getImportedClasses(), getImportedRoutines(), getInstalledClasses(), getInstalledPublicClasses(), getInstalledPublicRoutines(), getInstalledRoutines(), getPackages(), and RexxCode::install().

◆ install() [2/2]

void RexxSource::install ( RexxActivation * activation )

inline

Definition at line 284 of file SourceFile.hpp.

References needsInstallation(), and processInstall().

◆ instruction()

RexxInstruction * RexxSource::instruction ( )

Definition at line 3837 of file SourceFile.cpp.

References _interpret, addressNew(), assignmentNew(), assignmentOpNew(), callNew(), RexxToken::classId, commandNew(), doNew(), dropNew(), elseNew(), endNew(), Error_Invalid_expression_general, Error_Translation_expose_interpret, Error_Translation_forward_interpret, Error_Translation_guard_interpret, Error_Translation_reply_interpret, Error_Translation_use_interpret, Error_Unexpected_label_interpret, Error_Unexpected_then_then, exitNew(), exposeNew(), firstToken(), flags, forwardNew(), guardNew(), ifNew(), interpretNew(), RexxToken::isEndOfClause(), RexxToken::isSymbol(), keyword(), KEYWORD_ADDRESS, KEYWORD_ARG, KEYWORD_CALL, KEYWORD_DO, KEYWORD_DROP, KEYWORD_ELSE, KEYWORD_END, KEYWORD_EXIT, KEYWORD_EXPOSE, KEYWORD_FORWARD, KEYWORD_GUARD, KEYWORD_IF, KEYWORD_INTERPRET, KEYWORD_ITERATE, KEYWORD_LEAVE, KEYWORD_LOOP, KEYWORD_NOP, KEYWORD_NUMERIC, KEYWORD_OPTIONS, KEYWORD_OTHERWISE, KEYWORD_PARSE, KEYWORD_PROCEDURE, KEYWORD_PULL, KEYWORD_PUSH, KEYWORD_QUEUE, KEYWORD_RAISE, KEYWORD_REPLY, KEYWORD_RETURN, KEYWORD_SAY, KEYWORD_SELECT, KEYWORD_SIGNAL, KEYWORD_THEN, KEYWORD_TRACE, KEYWORD_USE, KEYWORD_WHEN, labelNew(), leaveNew(), loopNew(), messageAssignmentNew(), messageAssignmentOpNew(), messageNew(), messageTerm(), nextReal(), nextToken(), nopNew(), numericNew(), OPERATOR_EQUAL, OPERATOR_STRICT_EQUAL, optionsNew(), OREF_NULL, otherwiseNew(), parseNew(), previousToken(), procedureNew(), QUEUE_FIFO, QUEUE_LIFO, queueNew(), raiseNew(), reclaimClause(), replyNew(), returnNew(), saveObject(), sayNew(), selectNew(), signalNew(), RexxToken::subclass, subExpression(), SUBKEY_ARG, SUBKEY_PULL, syntaxError(), TERM_EOC, TOKEN_ASSIGNMENT, TOKEN_COLON, TOKEN_DCOLON, TOKEN_LITERAL, TOKEN_SYMBOL, toss(), traceNew(), trimClause(), and useNew().

Referenced by translateBlock().

◆ instructionNew()

RexxInstruction * RexxSource::instructionNew ( int type )

Definition at line 1126 of file InstructionParser.cpp.

References KEYWORD_INSTRUCTION, RexxInstruction::setType(), sourceNewObject(), TheInstructionBehaviour, and type.

◆ interpret()

RexxCode * RexxSource::interpret	(	RexxString *	string,
		RexxDirectory *	_labels,
		size_t	_line_number
	)

Definition at line 1231 of file SourceFile.cpp.

References interpretLine(), interpretMethod(), new_array(), programName, and RexxSource().

Referenced by RexxCode::interpret().

◆ interpretLine()

void RexxSource::interpretLine ( size_t _line_number )

Definition at line 362 of file SourceFile.cpp.

References interpret_adjust, line_count, and line_number.

Referenced by interpret().

◆ interpretMethod()

RexxCode * RexxSource::interpretMethod ( RexxDirectory * _labels )

Definition at line 1217 of file SourceFile.cpp.

References _interpret, cleanup(), flags, globalSetup(), and translate().

Referenced by interpret().

◆ interpretNew()

RexxInstruction * RexxSource::interpretNew ( )

Definition at line 1138 of file InstructionParser.cpp.

References Error_Invalid_expression_interpret, expression(), INTERPRET, new_instruction, OREF_NULL, syntaxError(), and TERM_EOC.

Referenced by instruction().

◆ isExposeValid()

void RexxSource::isExposeValid ( )

Definition at line 5416 of file SourceFile.cpp.

References _interpret, Error_Translation_expose, Error_Translation_expose_interpret, flags, RexxInstruction::getType(), KEYWORD_FIRST, last, and syntaxError().

Referenced by exposeNew().

◆ isInternalCode()

bool RexxSource::isInternalCode ( )

inline

Definition at line 317 of file SourceFile.hpp.

References RexxInternalObject::isOldSpace().

Referenced by traceBack().

◆ isInterpret()

bool RexxSource::isInterpret ( )

inline

Definition at line 281 of file SourceFile.hpp.

References _interpret, and flags.

Referenced by RexxCode::isInterpret().

◆ isSymbolCharacter()

static bool RexxSource::isSymbolCharacter ( char ch )

inlinestatic

Definition at line 374 of file SourceFile.hpp.

References characterTable.

Referenced by RexxVariableDictionary::getDirectVariableRetriever(), RexxString::isSymbol(), and sourceNextToken().

◆ isTraceable()

bool RexxSource::isTraceable ( )

Definition at line 780 of file SourceFile.cpp.

References OREF_NULL, reconnect(), sourceArray, and sourceBuffer.

Referenced by RexxCode::isTraceable().

◆ keyDirective()

int RexxSource::keyDirective ( RexxToken * token )

static

Definition at line 549 of file KeywordConstants.cpp.

References directives, RexxToken::isSymbol(), resolveKeyword(), tabSize, and RexxToken::value.

Referenced by directive().

◆ keyword()

int RexxSource::keyword ( RexxToken * token )

static

Definition at line 482 of file KeywordConstants.cpp.

References RexxToken::isSymbol(), keywordInstructions, resolveKeyword(), tabSize, and RexxToken::value.

Referenced by instruction(), and translateBlock().

◆ labelNew()

RexxInstruction * RexxSource::labelNew ( )

Definition at line 1157 of file InstructionParser.cpp.

References addLabel(), SourceLocation::getEndLine(), SourceLocation::getEndOffset(), RexxToken::getLocation(), new_instruction, nextReal(), nextToken(), RexxInstruction::setEnd(), and RexxToken::value.

Referenced by instruction().

◆ leaveNew()

RexxInstruction * RexxSource::leaveNew ( int type )

Definition at line 1177 of file InstructionParser.cpp.

References Error_Invalid_data_iterate, Error_Invalid_data_leave, Error_Symbol_expected_iterate, Error_Symbol_expected_leave, RexxToken::isEndOfClause(), RexxToken::isSymbol(), KEYWORD_LEAVE, new_instruction, nextReal(), OREF_NULL, syntaxError(), type, and RexxToken::value.

Referenced by instruction().

◆ libraryDirective()

void RexxSource::libraryDirective	(	RexxString *	name,
		RexxToken *	token
	)

Process a ::REQUIRES name LIBRARY directive.

Definition at line 3361 of file SourceFile.cpp.

References _install, RexxList::append(), clause, Error_Invalid_subkeyword_requires, flags, RexxToken::isEndOfClause(), RexxToken::isSymbol(), libraries, nextReal(), subDirective(), SUBDIRECTIVE_LIBRARY, and syntaxError().

Referenced by requiresDirective().

◆ live()

void RexxSource::live ( size_t liveMark )

virtual

Reimplemented from RexxVirtualBase.

Definition at line 585 of file SourceFile.cpp.

References active_class, calls, class_dependencies, classes, clause, control, currentInstruction, exposed_variables, first, guard_variables, holdstack, initCode, installed_classes, installed_public_classes, labels, last, libraries, literals, loadedPackages, memory_mark, merged_public_classes, merged_public_routines, methods, operators, package, parentSource, programDirectory, programExtension, programFile, programName, public_routines, requires, routines, savelist, securityManager, sourceArray, sourceBuffer, sourceIndices, strings, subTerms, terms, and variables.

◆ liveGeneral()

void RexxSource::liveGeneral ( int reason )

virtual

Reimplemented from RexxVirtualBase.

Definition at line 633 of file SourceFile.cpp.

References active_class, calls, class_dependencies, classes, clause, control, currentInstruction, exposed_variables, first, flags, guard_variables, holdstack, initCode, installed_classes, installed_public_classes, labels, last, libraries, literals, loadedPackages, memory_mark_general, memoryObject, merged_public_classes, merged_public_routines, methods, operators, OREF_NULL, OrefSet, package, parentSource, programDirectory, programExtension, programFile, programName, public_routines, reclaim_possible, requires, routines, savelist, RexxMemory::savingImage(), securityManager, sourceArray, sourceBuffer, sourceIndices, strings, subTerms, terms, and variables.

◆ loadRequires() [1/2]

PackageClass * RexxSource::loadRequires	(	RexxActivity *	activity,
		RexxString *	target
	)

Load a ::REQUIRES directive when the source file is first invoked.

Parameters

target	The name of the ::REQUIRES
instruction	The directive instruction being processed.

Definition at line 6072 of file SourceFile.cpp.

References addPackage(), Error_Routine_not_found_requires, RexxActivity::getInstance(), InterpreterInstance::loadRequires(), OREF_NULL, reportException(), and resolveProgramName().

Referenced by PackageClass::loadPackage(), and RexxActivation::loadRequires().

◆ loadRequires() [2/2]

PackageClass * RexxSource::loadRequires	(	RexxActivity *	activity,
		RexxString *	target,
		RexxArray *	s
	)

Load a ::REQUIRES directive from an provided source target

Parameters

target The name of the ::REQUIRES

Definition at line 6101 of file SourceFile.cpp.

References addPackage(), Error_Routine_not_found_requires, RexxActivity::getInstance(), InterpreterInstance::loadRequires(), OREF_NULL, and reportException().

◆ locateToken()

unsigned int RexxSource::locateToken ( RexxToken * previous )

Definition at line 270 of file Scanner.cpp.

References RexxToken::classId, CLAUSEEND_EOF, CLAUSEEND_EOL, comment(), current, current_length, GETCHAR, line_count, line_number, line_offset, MORELINE, nextLine(), OREF_NULL, position(), TOKEN_BLANK, TOKEN_LITERAL, TOKEN_RIGHT, TOKEN_SQRIGHT, and TOKEN_SYMBOL.

Referenced by nextSpecial(), and sourceNextToken().

◆ loopNew()

RexxInstruction * RexxSource::loopNew ( )

Definition at line 454 of file InstructionParser.cpp.

References createDoLoop(), and createLoop().

Referenced by instruction().

◆ markPosition()

size_t RexxSource::markPosition ( )

inline

Definition at line 307 of file SourceFile.hpp.

References clause, and RexxClause::mark().

Referenced by createDoLoop(), and messageTerm().

◆ mergeRequired()

void RexxSource::mergeRequired ( RexxSource * source )

Definition at line 1365 of file SourceFile.cpp.

References RexxHashTableCollection::available(), RexxHashTableCollection::first(), RexxHashTableCollection::index(), installed_public_classes, merged_public_classes, merged_public_routines, new_directory(), RexxHashTableCollection::next(), OREF_NULL, OrefSet, public_routines, RexxDirectory::setEntry(), and RexxHashTableCollection::value().

Referenced by addPackage(), RexxActivation::callMacroSpaceFunction(), and RexxCode::mergeRequired().

◆ message()

RexxObject * RexxSource::message	(	RexxObject *	target,
		bool	doubleTilde,
		int	terminators
	)

Definition at line 5046 of file SourceFile.cpp.

References addText(), argList(), RexxToken::classId, Error_Symbol_expected_colon, Error_Symbol_or_string_tilde, getToken(), holdObject(), RexxToken::isSymbolOrLiteral(), RexxToken::isVariable(), OREF_NULL, popTerm(), previousToken(), pushTerm(), removeObj(), saveObject(), RexxToken::subclass, subTerms, SYMBOL_DOTSYMBOL, syntaxError(), TERM_RIGHT, TERM_SQRIGHT, TOKEN_COLON, TOKEN_LEFT, and RexxToken::value.

Referenced by messageSubterm(), messageTerm(), and subExpression().

◆ messageAssignmentNew()

RexxInstruction * RexxSource::messageAssignmentNew	(	RexxExpressionMessage *	_message,
		RexxObject *	_expression
	)

Definition at line 1238 of file InstructionParser.cpp.

References RexxExpressionMessage::argumentCount, RexxExpressionMessage::makeAssignment(), and new_variable_instruction.

Referenced by instruction().

◆ messageAssignmentOpNew()

RexxInstruction * RexxSource::messageAssignmentOpNew	(	RexxExpressionMessage *	_message,
		RexxToken *	operation,
		RexxObject *	_expression
	)

Create a message term pseudo assignment instruction for a shortcut operator. The instruction is of the form "messageTerm (op)= expr".

Parameters

message	The target message term.
operation	The operation to perform in the expansion.
expression	The expression (which is the right-hand term of the eventual expression).

Returns: The constructed message operator.

Definition at line 1267 of file InstructionParser.cpp.

References RexxExpressionMessage::argumentCount, RexxInternalObject::copy(), RexxExpressionMessage::makeAssignment(), new_variable_instruction, and RexxToken::subclass.

Referenced by instruction().

◆ messageNew()

RexxInstruction * RexxSource::messageNew ( RexxExpressionMessage * _message )

Definition at line 1224 of file InstructionParser.cpp.

References RexxExpressionMessage::argumentCount, and new_variable_instruction.

Referenced by instruction().

◆ messageSubterm()

RexxObject * RexxSource::messageSubterm ( int terminators )

Definition at line 5206 of file SourceFile.cpp.

References RexxToken::classId, collectionMessage(), Error_Invalid_expression_general, Error_Invalid_expression_prefix, holdObject(), message(), nextToken(), OPERATOR_BACKSLASH, OPERATOR_PLUS, OPERATOR_SUBTRACT, OREF_NULL, previousToken(), RexxToken::subclass, subTerm(), syntaxError(), TERM_EOC, terminator(), TOKEN_DTILDE, TOKEN_OPERATOR, TOKEN_SQLEFT, and TOKEN_TILDE.

Referenced by subExpression().

◆ messageTerm()

RexxObject * RexxSource::messageTerm ( )

Definition at line 5163 of file SourceFile.cpp.

References RexxToken::classId, collectionMessage(), holdObject(), markPosition(), message(), nextToken(), OREF_NULL, previousToken(), resetPosition(), subTerm(), TERM_EOC, TOKEN_DTILDE, TOKEN_SQLEFT, and TOKEN_TILDE.

Referenced by instruction(), and variableOrMessageTerm().

◆ methodDirective()

void RexxSource::methodDirective ( )

Process a ::METHOD directive in a source file.

Definition at line 2150 of file SourceFile.cpp.

References addMethod(), checkDirective(), checkDuplicateMethod(), commonString(), RexxString::concatToCstring(), RexxString::concatWithCstring(), createAttributeGetterMethod(), createAttributeSetterMethod(), createNativeMethod(), decodeExternalMethod(), DEFAULT_ACCESS_SCOPE, DEFAULT_GUARD, DEFAULT_PROTECTION, Error_Invalid_subkeyword_method, Error_Symbol_or_string_external, Error_Symbol_or_string_method, Error_Translation_abstract_method, Error_Translation_attribute_method, Error_Translation_duplicate_method, Error_Translation_external_method, getRetriever(), GUARDED_METHOD, RexxToken::isEndOfClause(), RexxToken::isLiteral(), RexxToken::isSymbol(), RexxToken::isSymbolOrLiteral(), nextReal(), OREF_NULL, PRIVATE_SCOPE, PROTECTED_METHOD, PUBLIC_SCOPE, saveObject(), RexxMethod::setAttributes(), subDirective(), SUBDIRECTIVE_ABSTRACT, SUBDIRECTIVE_ATTRIBUTE, SUBDIRECTIVE_CLASS, SUBDIRECTIVE_EXTERNAL, SUBDIRECTIVE_GUARDED, SUBDIRECTIVE_PRIVATE, SUBDIRECTIVE_PROTECTED, SUBDIRECTIVE_PUBLIC, SUBDIRECTIVE_UNGUARDED, SUBDIRECTIVE_UNPROTECTED, syntaxError(), translateBlock(), UNGUARDED_METHOD, UNPROTECTED_METHOD, RexxString::upper(), and RexxToken::value.

Referenced by directive().

◆ needsInstallation()

bool RexxSource::needsInstallation ( )

inline

Definition at line 283 of file SourceFile.hpp.

References _install, and flags.

Referenced by install().

◆ needVariable()

void RexxSource::needVariable ( RexxToken * token )

Definition at line 379 of file SourceFile.cpp.

References Error_Invalid_variable_number, Error_Invalid_variable_period, RexxString::getChar(), RexxToken::isVariable(), syntaxError(), and RexxToken::value.

Referenced by addVariable(), assignmentNew(), assignmentOpNew(), and variableOrMessageTerm().

◆ needVariableOrDotSymbol()

void RexxSource::needVariableOrDotSymbol ( RexxToken * token )

Definition at line 400 of file SourceFile.cpp.

References Error_Invalid_variable_number, RexxToken::isVariable(), RexxToken::subclass, SYMBOL_DOTSYMBOL, and syntaxError().

◆ nextClause()

void RexxSource::nextClause ( )

Definition at line 838 of file SourceFile.cpp.

References clause, clauseLocation, flags, RexxClause::getLocation(), RexxToken::getLocation(), RexxToken::isEndOfClause(), line_number, line_offset, RexxClause::newClause(), no_clause, OREF_NULL, reclaimed, SourceLocation::setEnd(), RexxClause::setLocation(), RexxClause::setStart(), and sourceNextToken().

Referenced by checkDirective(), directive(), hasBody(), translate(), and translateBlock().

◆ nextLine()

void RexxSource::nextLine ( )

Definition at line 500 of file SourceFile.cpp.

References clause, line_number, line_offset, position(), and RexxClause::setEnd().

Referenced by comment(), locateToken(), and sourceNextToken().

◆ nextReal()

RexxToken* RexxSource::nextReal ( )

inline

◆ nextSpecial()

bool RexxSource::nextSpecial	(	unsigned int	target,
		SourceLocation &	location
	)

Definition at line 206 of file Scanner.cpp.

References CLAUSEEND_EOF, CLAUSEEND_EOL, endLocation(), GETCHAR, line_offset, locateToken(), and OREF_NULL.

Referenced by RexxToken::checkAssignment(), and sourceNextToken().

◆ nextToken()

RexxToken* RexxSource::nextToken ( )

inline

Definition at line 302 of file SourceFile.hpp.

References clause, and RexxClause::next().

Referenced by argList(), constantExpression(), constantLogicalExpression(), getToken(), instruction(), labelNew(), messageSubterm(), messageTerm(), parenExpression(), parseConditional(), parseNew(), raiseNew(), subExpression(), and subTerm().

◆ nopNew()

RexxInstruction * RexxSource::nopNew ( )

Definition at line 1288 of file InstructionParser.cpp.

References Error_Invalid_data_nop, RexxToken::isEndOfClause(), new_instruction, nextReal(), and syntaxError().

Referenced by instruction().

◆ numericNew()

RexxInstruction * RexxSource::numericNew ( )

◆ operator delete() [1/2]

void RexxSource::operator delete ( void * )

inline

Definition at line 136 of file SourceFile.hpp.

◆ operator delete() [2/2]

void RexxSource::operator delete	(	void *	,
		void *
	)

inline

Definition at line 137 of file SourceFile.hpp.

◆ operator new() [1/2]

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

inline

Definition at line 135 of file SourceFile.hpp.

◆ operator new() [2/2]

void * RexxSource::operator new ( size_t size )

Definition at line 5679 of file SourceFile.cpp.

References new_object(), and T_RexxSource.

◆ optionsDirective()

void RexxSource::optionsDirective ( )

Process a ::OPTIONS directive in a source file.

Definition at line 2403 of file SourceFile.cpp.

References digits, Error_Expression_result_digits, Error_Invalid_subkeyword_form, Error_Invalid_subkeyword_options, Error_Invalid_trace_trace, Error_Invalid_whole_number_digits, Error_Invalid_whole_number_fuzz, Error_Symbol_or_string_digits_value, Error_Symbol_or_string_fuzz_value, Error_Symbol_or_string_trace_value, form, Numerics::FORM_ENGINEERING, Numerics::FORM_SCIENTIFIC, fuzz, RexxToken::isEndOfClause(), RexxToken::isSymbol(), RexxToken::isSymbolOrLiteral(), new_string(), nextReal(), number_digits(), parseTraceSetting(), reportException(), RexxObject::requestUnsignedNumber(), subDirective(), SUBDIRECTIVE_DIGITS, SUBDIRECTIVE_FORM, SUBDIRECTIVE_FUZZ, SUBDIRECTIVE_TRACE, SUBKEY_ENGINEERING, SUBKEY_SCIENTIFIC, subKeyword(), syntaxError(), traceFlags, traceSetting, and RexxToken::value.

Referenced by directive().

◆ optionsNew()

RexxInstruction * RexxSource::optionsNew ( )

Definition at line 1408 of file InstructionParser.cpp.

References Error_Invalid_expression_options, expression(), new_instruction, OREF_NULL, syntaxError(), and TERM_EOC.

Referenced by instruction().

◆ otherwiseNew()

RexxInstruction * RexxSource::otherwiseNew ( RexxToken * token )

Definition at line 1425 of file InstructionParser.cpp.

References new_instruction.

Referenced by instruction().

◆ packLiteral()

RexxString * RexxSource::packLiteral	(	size_t	start,
		size_t	length,
		int	type
	)

Definition at line 407 of file Scanner.cpp.

References clause, clauseLocation, commonString(), current, Error_Invalid_hex_binblank, Error_Invalid_hex_hexblank, Error_Invalid_hex_invbin, Error_Invalid_hex_invhex, RexxClause::getLocation(), LITERAL_BIN, LITERAL_HEX, new_integer(), new_string(), RexxString::putChar(), raw_string(), syntaxError(), and type.

Referenced by sourceNextToken().

◆ parenExpression()

RexxObject * RexxSource::parenExpression ( RexxToken * start )

Definition at line 4691 of file SourceFile.cpp.

References RexxToken::classId, Error_Unmatched_parenthesis_paren, holdObject(), nextToken(), subExpression(), syntaxErrorAt(), TERM_EOC, TERM_RIGHT, and TOKEN_RIGHT.

Referenced by callNew(), and parseNew().

◆ parseConditional()

RexxObject * RexxSource::parseConditional	(	int *	condition_type,
		int	error_message
	)

Definition at line 5953 of file SourceFile.cpp.

References Error_Invalid_do_whileuntil, Error_Invalid_expression_until, Error_Invalid_expression_while, RexxToken::isEndOfClause(), RexxToken::isSymbol(), nextReal(), nextToken(), OREF_NULL, parseLogical(), SUBKEY_UNTIL, SUBKEY_WHILE, subKeyword(), syntaxError(), and TERM_COND.

◆ parseLogical()

RexxObject * RexxSource::parseLogical	(	RexxToken *	_first,
		int	terminators
	)

Parse off a "logical list expression", consisting of a list of conditionals separated by commas.

Parameters

terminators The set of terminators for this logical context.

Returns: OREF_NULL if no expressions is found, a single expression element if a single expression is located, and a complex logical expression operator for a list of expressions.

Definition at line 6042 of file SourceFile.cpp.

References argList(), OREF_NULL, RexxQueue::pop(), previousToken(), and subTerms.

Referenced by constantLogicalExpression(), ifNew(), and parseConditional().

◆ parseNew()

RexxInstruction * RexxSource::parseNew ( int argpull )

Definition at line 1438 of file InstructionParser.cpp.

References addText(), addVariable(), RexxToken::classId, Error_Invalid_expression_parse, Error_Invalid_subkeyword_parse, Error_Invalid_template_missing, Error_Invalid_template_position, Error_Invalid_template_trigger, Error_Invalid_template_with, Error_Symbol_expected_parse, Error_Symbol_expected_var, Error_Variable_expected_PARSE, expression(), RexxToken::isEndOfClause(), RexxToken::isLiteral(), RexxToken::isSymbol(), KEYWORD_PARSE, new_variable_instruction, nextReal(), nextToken(), OPERATOR_EQUAL, OPERATOR_GREATERTHAN, OPERATOR_LESSTHAN, OPERATOR_PLUS, OPERATOR_SUBTRACT, OREF_NULL, parenExpression(), parse_caseless, parse_lower, parse_translate, parse_upper, parseOption(), previousToken(), RexxQueue::push(), saveObject(), RexxToken::subclass, SUBKEY_ARG, SUBKEY_CASELESS, SUBKEY_LINEIN, SUBKEY_LOWER, SUBKEY_PULL, SUBKEY_SOURCE, SUBKEY_UPPER, SUBKEY_VALUE, SUBKEY_VAR, SUBKEY_VERSION, SUBKEY_WITH, subKeyword(), subTerms, SYMBOL_CONSTANT, SYMBOL_DUMMY, syntaxError(), TERM_KEYWORD, TERM_WITH, terms, TOKEN_COMMA, TOKEN_LEFT, TOKEN_OPERATOR, toss(), TRIGGER_ABSOLUTE, TRIGGER_END, TRIGGER_MINUS, TRIGGER_MINUS_LENGTH, TRIGGER_MIXED, TRIGGER_PLUS, TRIGGER_PLUS_LENGTH, TRIGGER_STRING, and variableOrMessageTerm().

Referenced by instruction().

◆ parseOption()

int RexxSource::parseOption ( RexxToken * token )

static

Definition at line 535 of file KeywordConstants.cpp.

References RexxToken::isSymbol(), parseOptions, resolveKeyword(), tabSize, and RexxToken::value.

Referenced by parseNew().

◆ parseTraceSetting()

bool RexxSource::parseTraceSetting	(	RexxString *	value,
		size_t &	newSetting,
		size_t &	debugFlags,
		char &	badOption
	)

static

Parse a trace setting value into a decoded setting and the RexxActivation debug flag set to allow new trace settings to be processed more quickly.

Parameters

value	The string source of the trace setting.
newSetting	The returned setting in binary form.
debugFlags	The debug flag representation of the trace setting.

Definition at line 5715 of file SourceFile.cpp.

References DEBUG_IGNORE, DEBUG_OFF, DEBUG_TOGGLE, RexxString::getChar(), RexxString::getLength(), RexxActivation::processTraceSetting(), TRACE_ALL, TRACE_COMMANDS, TRACE_ERRORS, TRACE_FAILURES, TRACE_IGNORE, TRACE_INTERMEDIATES, TRACE_LABELS, TRACE_NORMAL, TRACE_OFF, and TRACE_RESULTS.

Referenced by optionsDirective(), RexxActivation::setTrace(), and traceNew().

◆ popDo()

RexxInstruction* RexxSource::popDo ( )

inline

Definition at line 287 of file SourceFile.hpp.

References control, and RexxQueue::pullRexx().

Referenced by flushControl(), and translateBlock().

◆ popNTerms()

RexxObject * RexxSource::popNTerms ( size_t count )

Definition at line 5399 of file SourceFile.cpp.

References currentstack, holdObject(), OREF_NULL, RexxQueue::pop(), and terms.

Referenced by argList().

◆ popOperator()

RexxToken* RexxSource::popOperator ( )

inline

Definition at line 297 of file SourceFile.hpp.

References operators, and RexxQueue::pullRexx().

Referenced by subExpression().

◆ popTerm()

RexxObject * RexxSource::popTerm ( )

Definition at line 5386 of file SourceFile.cpp.

References currentstack, holdObject(), RexxQueue::pop(), and terms.

Referenced by message(), and subExpression().

◆ position()

void RexxSource::position	(	size_t	line,
		size_t	offset
	)

◆ precedence()

int RexxSource::precedence ( RexxToken * token )

static

Definition at line 51 of file Scanner.cpp.

References OPERATOR_ABUTTAL, OPERATOR_AND, OPERATOR_BACKSLASH, OPERATOR_BACKSLASH_EQUAL, OPERATOR_BACKSLASH_GREATERTHAN, OPERATOR_BACKSLASH_LESSTHAN, OPERATOR_BLANK, OPERATOR_CONCATENATE, OPERATOR_DIVIDE, OPERATOR_EQUAL, OPERATOR_GREATERTHAN, OPERATOR_GREATERTHAN_EQUAL, OPERATOR_GREATERTHAN_LESSTHAN, OPERATOR_INTDIV, OPERATOR_LESSTHAN, OPERATOR_LESSTHAN_EQUAL, OPERATOR_LESSTHAN_GREATERTHAN, OPERATOR_MULTIPLY, OPERATOR_OR, OPERATOR_PLUS, OPERATOR_POWER, OPERATOR_REMAINDER, OPERATOR_STRICT_BACKSLASH_EQUAL, OPERATOR_STRICT_BACKSLASH_GREATERTHAN, OPERATOR_STRICT_BACKSLASH_LESSTHAN, OPERATOR_STRICT_EQUAL, OPERATOR_STRICT_GREATERTHAN, OPERATOR_STRICT_GREATERTHAN_EQUAL, OPERATOR_STRICT_LESSTHAN, OPERATOR_STRICT_LESSTHAN_EQUAL, OPERATOR_SUBTRACT, OPERATOR_XOR, and RexxToken::subclass.

Referenced by subExpression().

◆ previousToken()

void RexxSource::previousToken ( )

inline

Definition at line 304 of file SourceFile.hpp.

References clause, and RexxClause::previous().

Referenced by addressNew(), argList(), classDirective(), constantExpression(), constantLogicalExpression(), createDoLoop(), expression(), ifNew(), instruction(), message(), messageSubterm(), messageTerm(), numericNew(), parseLogical(), parseNew(), signalNew(), subExpression(), subTerm(), terminator(), traceNew(), translateBlock(), useNew(), and variableOrMessageTerm().

◆ procedureNew()

RexxInstruction * RexxSource::procedureNew ( )

Definition at line 1737 of file InstructionParser.cpp.

References Error_Invalid_subkeyword_procedure, RexxToken::isEndOfClause(), RexxToken::isSymbol(), KEYWORD_PROCEDURE, new_variable_instruction, nextReal(), processVariableList(), SUBKEY_EXPOSE, subKeyword(), subTerms, and syntaxError().

Referenced by instruction().

◆ processInstall()

void RexxSource::processInstall ( RexxActivation * activation )

Definition at line 1678 of file SourceFile.cpp.

References _install, classes, RexxList::firstIndex(), flags, RexxArray::get(), RexxList::getValue(), LibraryDirective::install(), RequiresDirective::install(), ClassDirective::install(), installed_classes, installed_public_classes, RexxList::items(), libraries, LIST_END, new_array(), new_directory(), RexxList::nextIndex(), OREF_NULL, OrefSet, RexxArray::put(), requires, and RexxObject::sendMessage().

Referenced by install().

◆ processVariableList()

size_t RexxSource::processVariableList ( int type )

◆ pushDo()

void RexxSource::pushDo ( RexxInstruction * i )

inline

Definition at line 286 of file SourceFile.hpp.

References control, and RexxQueue::pushRexx().

Referenced by flushControl(), and translateBlock().

◆ pushOperator()

void RexxSource::pushOperator ( RexxToken * operatorToken )

inline

Definition at line 296 of file SourceFile.hpp.

References operators, and RexxQueue::pushRexx().

Referenced by subExpression().

◆ pushTerm()

void RexxSource::pushTerm ( RexxObject * term )

Definition at line 5370 of file SourceFile.cpp.

References currentstack, maxstack, RexxQueue::push(), and terms.

Referenced by argList(), message(), and subExpression().

◆ queueNew()

RexxInstruction * RexxSource::queueNew ( int type )

Definition at line 1766 of file InstructionParser.cpp.

References expression(), new_instruction, TERM_EOC, and type.

Referenced by instruction().

◆ raiseNew()

RexxInstruction * RexxSource::raiseNew ( )

Definition at line 1780 of file InstructionParser.cpp.

References argList(), CHAR_USER_BLANK, RexxToken::classId, commonString(), RexxString::concatToCstring(), condition(), CONDITION_ERROR, CONDITION_FAILURE, CONDITION_HALT, CONDITION_LOSTDIGITS, CONDITION_NOMETHOD, CONDITION_NOSTRING, CONDITION_NOTREADY, CONDITION_NOVALUE, CONDITION_PROPAGATE, CONDITION_SYNTAX, CONDITION_USER, constantExpression(), Error_Invalid_expression_general, Error_Invalid_expression_raise_additional, Error_Invalid_expression_raise_description, Error_Invalid_expression_raise_list, Error_Invalid_subkeyword_additional, Error_Invalid_subkeyword_description, Error_Invalid_subkeyword_raise, Error_Invalid_subkeyword_raiseoption, Error_Invalid_subkeyword_result, Error_Symbol_expected_raise, Error_Symbol_expected_user, RexxToken::isEndOfClause(), RexxToken::isSymbol(), new_instruction, new_queue(), new_variable_instruction, nextReal(), nextToken(), OREF_NULL, RexxQueue::push(), RexxQueue::queue(), saveObject(), SUBKEY_ADDITIONAL, SUBKEY_ARRAY, SUBKEY_DESCRIPTION, SUBKEY_EXIT, SUBKEY_RETURN, subKeyword(), subTerms, syntaxError(), TERM_RIGHT, TOKEN_LEFT, toss(), and RexxToken::value.

Referenced by instruction().

◆ reclaimClause()

void RexxSource::reclaimClause ( )

inline

Definition at line 299 of file SourceFile.hpp.

References flags, and reclaimed.

Referenced by checkDirective(), hasBody(), and instruction().

◆ reconnect()

bool RexxSource::reconnect ( )

Definition at line 341 of file SourceFile.cpp.

References flags, initFile(), and reclaim_possible.

Referenced by extract(), extractSource(), isTraceable(), and sourceSize().

◆ removeObj()

void RexxSource::removeObj ( RexxObject * object )

inline

Definition at line 365 of file SourceFile.hpp.

References OREF_NULL, RexxIdentityTable::remove(), and savelist.

Referenced by collectionMessage(), function(), message(), and useNew().

◆ replyNew()

RexxInstruction * RexxSource::replyNew ( )

Definition at line 1970 of file InstructionParser.cpp.

References expression(), new_instruction, and TERM_EOC.

Referenced by instruction().

◆ requiresDirective()

void RexxSource::requiresDirective ( )

Process a ::REQUIRES directive.

Definition at line 3335 of file SourceFile.cpp.

References _install, RexxList::append(), clause, Error_Symbol_or_string_requires, flags, RexxToken::isEndOfClause(), RexxToken::isSymbolOrLiteral(), libraryDirective(), nextReal(), requires, syntaxError(), and RexxToken::value.

Referenced by directive().

◆ resetPosition()

void RexxSource::resetPosition ( size_t p )

inline

Definition at line 308 of file SourceFile.hpp.

References clause, and RexxClause::reset().

Referenced by createDoLoop(), and messageTerm().

◆ resolveBuiltin()

size_t RexxSource::resolveBuiltin ( RexxString * value )

static

Definition at line 511 of file KeywordConstants.cpp.

References builtinFunctions, resolveKeyword(), and tabSize.

Referenced by RexxInstructionCall::execute().

◆ resolveDependencies()

void RexxSource::resolveDependencies ( )

◆ resolveKeyword()

int RexxSource::resolveKeyword	(	RexxString *	token,
		KeywordEntry *	Table,
		int	Table_Size
	)

static

Resolve a token to a potential subkeyword.

Parameters

token	The token to resolve.
Table	The table to search.
Table_Size	The size of the table.

Returns: The numeric identifier for the constant. Returns 0 if not found in the target table.

Definition at line 408 of file KeywordConstants.cpp.

References RexxString::getLength(), RexxString::getStringData(), KeywordEntry::keyword_code, and Numerics::minVal().

Referenced by builtin(), condition(), keyDirective(), keyword(), parseOption(), resolveBuiltin(), subDirective(), and subKeyword().

◆ resolveProgramName()

RexxString * RexxSource::resolveProgramName	(	RexxActivity *	activity,
		RexxString *	name
	)

Resolve an external call in the context of the program making the call. This will use the directory and extension of the context program to modify the search order.

Parameters

activity	The current activity
name	The target name

Returns: The fully resolved string name of the target program, if one is located.

Definition at line 1541 of file SourceFile.cpp.

References RexxActivity::getInstance(), programDirectory, programExtension, and InterpreterInstance::resolveProgramName().

Referenced by loadRequires(), and RexxCode::resolveProgramName().

◆ returnNew()

RexxInstruction * RexxSource::returnNew ( )

Definition at line 1983 of file InstructionParser.cpp.

References expression(), new_instruction, and TERM_EOC.

Referenced by instruction().

◆ RexxInstructionForwardCreate()

void RexxSource::RexxInstructionForwardCreate ( RexxInstructionForward * newObject )

Definition at line 881 of file InstructionParser.cpp.

References RexxInstructionForward::arguments, RexxInstructionForward::array, RexxToken::classId, Error_Invalid_expression_forward_arguments, Error_Invalid_expression_forward_class, Error_Invalid_expression_forward_message, Error_Invalid_expression_forward_to, Error_Invalid_expression_raise_list, Error_Invalid_subkeyword_arguments, Error_Invalid_subkeyword_continue, Error_Invalid_subkeyword_forward_class, Error_Invalid_subkeyword_forward_option, Error_Invalid_subkeyword_message, Error_Invalid_subkeyword_to, forward_continue, RexxInstruction::instructionFlags, RexxToken::isEndOfClause(), RexxToken::isSymbol(), RexxInstructionForward::message, nextReal(), OREF_NULL, OrefSet, SUBKEY_ARGUMENTS, SUBKEY_ARRAY, SUBKEY_CLASS, SUBKEY_CONTINUE, SUBKEY_MESSAGE, SUBKEY_TO, subKeyword(), RexxInstructionForward::superClass, syntaxError(), RexxInstructionForward::target, TERM_RIGHT, and TOKEN_LEFT.

Referenced by forwardNew().

◆ routineDirective()

void RexxSource::routineDirective ( )

Process a ::routine directive in a source file.

Definition at line 3129 of file SourceFile.cpp.

References _install, CHAR_LIBRARY, CHAR_REGISTERED, checkDirective(), DEFAULT_ACCESS_SCOPE, RexxDirectory::entry(), Error_External_name_not_found_routine, Error_Invalid_subkeyword_class, Error_Invalid_subkeyword_routine, Error_Symbol_or_string_requires, Error_Symbol_or_string_routine, Error_Translation_bad_external, Error_Translation_duplicate_routine, Error_Translation_external_routine, flags, RexxArray::get(), RexxToken::isEndOfClause(), RexxToken::isLiteral(), RexxToken::isSymbol(), RexxToken::isSymbolOrLiteral(), nextReal(), OREF_NULL, PRIVATE_SCOPE, public_routines, PUBLIC_SCOPE, PackageManager::resolveRoutine(), routines, saveObject(), RexxDirectory::setEntry(), BaseExecutable::setSourceObject(), RexxArray::size(), subDirective(), SUBDIRECTIVE_EXTERNAL, SUBDIRECTIVE_PRIVATE, SUBDIRECTIVE_PUBLIC, syntaxError(), toss(), translateBlock(), RexxToken::value, and words().

Referenced by directive().

◆ saveObject()

void RexxSource::saveObject ( RexxObject * object )

inline

Definition at line 364 of file SourceFile.hpp.

References RexxIdentityTable::put(), and savelist.

Referenced by collectionMessage(), createMethod(), function(), instruction(), message(), methodDirective(), parseNew(), raiseNew(), routineDirective(), and useNew().

◆ sayNew()

RexxInstruction * RexxSource::sayNew ( )

Definition at line 1997 of file InstructionParser.cpp.

References expression(), new_instruction, and TERM_EOC.

Referenced by instruction().

◆ selectNew()

RexxInstruction * RexxSource::selectNew ( )

Definition at line 2010 of file InstructionParser.cpp.

References Error_Invalid_data_select, Error_Invalid_subkeyword_select, Error_Symbol_expected_LABEL, RexxToken::isEndOfClause(), RexxToken::isSymbol(), new_instruction, nextReal(), OREF_NULL, SUBKEY_LABEL, subKeyword(), syntaxError(), and RexxToken::value.

Referenced by instruction().

◆ setBufferedSource()

void RexxSource::setBufferedSource ( RexxBuffer * newSource )

inline

Definition at line 148 of file SourceFile.hpp.

References initBuffered().

Referenced by RoutineClass::processInstore().

◆ setGuard()

void RexxSource::setGuard ( )

Definition at line 4566 of file SourceFile.cpp.

References guard_variables, new_identity_table(), OREF_NULL, and OrefSet.

Referenced by guardNew().

◆ setLocalRoutines()

void RexxSource::setLocalRoutines ( RexxDirectory * r )

inline

Definition at line 371 of file SourceFile.hpp.

References routines.

Referenced by RexxActivation::addLocalRoutine(), and RexxCode::setLocalRoutines().

◆ setProgramName()

void RexxSource::setProgramName ( RexxString * name )

Set a program name for this source object. Usually used after a program restore to update the restored routine object. This will also update the extension and directory information.

Parameters

name	The new program name.

Definition at line 335 of file SourceFile.cpp.

References extractNameInformation(), OrefSet, and programName.

Referenced by RoutineClass::restore(), and RexxSource().

◆ setPublicRoutines()

void RexxSource::setPublicRoutines ( RexxDirectory * r )

inline

Definition at line 372 of file SourceFile.hpp.

References public_routines.

Referenced by RexxCode::setPublicRoutines().

◆ setReconnect()

void RexxSource::setReconnect ( )

Definition at line 354 of file SourceFile.cpp.

References flags, and reclaim_possible.

◆ setSecurityManager()

void RexxSource::setSecurityManager ( RexxObject * manager )

inline

Definition at line 366 of file SourceFile.hpp.

References OrefSet, and securityManager.

Referenced by PackageClass::setSecurityManager(), and RexxCode::setSecurityManager().

◆ signalNew()

RexxInstruction * RexxSource::signalNew ( )

Definition at line 2061 of file InstructionParser.cpp.

References addReference(), CHAR_USER_BLANK, commonString(), RexxString::concatToCstring(), condition(), CONDITION_PROPAGATE, CONDITION_USER, Error_Invalid_data_condition, Error_Invalid_data_name, Error_Invalid_data_signal, Error_Invalid_expression_signal, Error_Invalid_subkeyword_signaloff, Error_Invalid_subkeyword_signalon, Error_Invalid_subkeyword_signalonname, Error_Symbol_expected_off, Error_Symbol_expected_on, Error_Symbol_expected_user, Error_Symbol_or_string_name, Error_Symbol_or_string_signal, expression(), RexxToken::isEndOfClause(), RexxToken::isSymbol(), RexxToken::isSymbolOrLiteral(), new_instruction, nextReal(), OREF_NULL, previousToken(), signal_on, SUBKEY_NAME, SUBKEY_OFF, SUBKEY_ON, SUBKEY_VALUE, subKeyword(), syntaxError(), TERM_EOC, and RexxToken::value.

Referenced by instruction().

◆ sourceNewObject()

RexxInstruction * RexxSource::sourceNewObject	(	size_t	size,
		RexxBehaviour *	_behaviour,
		int	type
	)

Definition at line 5689 of file SourceFile.cpp.

References clause, currentInstruction, new_object(), OrefSet, and RexxInternalObject::setBehaviour().

Referenced by instructionNew().

◆ sourceNextToken()

RexxToken * RexxSource::sourceNextToken ( RexxToken * previous )

Definition at line 619 of file Scanner.cpp.

References CHECK_ASSIGNMENT, clause, CLAUSEEND_EOF, CLAUSEEND_EOL, CLAUSEEND_SEMICOLON, clauseLocation, commonString(), current, current_length, Numerics::DEFAULT_DIGITS, endLocation(), Error_Invalid_character_char, Error_Name_too_long_name, Error_Unmatched_quote_double, Error_Unmatched_quote_single, EXP_DIGIT, EXP_E, EXP_EDIGIT, EXP_ESIGN, EXP_EXCLUDED, EXP_POINT, EXP_SPOINT, EXP_START, GETCHAR, RexxString::getChar(), RexxClause::getLocation(), INTEGER_CONSTANT, isSymbolCharacter(), line_number, line_offset, LITERAL_BIN, LITERAL_HEX, locateToken(), MAX_SYMBOL_LENGTH, MORELINE, new_string(), RexxClause::newToken(), nextLine(), nextSpecial(), OPERATOR, OPERATOR_BLANK, OREF_NULL, packLiteral(), RexxString::putChar(), raw_string(), RexxClause::setEnd(), SourceLocation::setEndOffset(), SourceLocation::setLocation(), RexxToken::setNumeric(), RexxString::setUpperOnly(), SYMBOL_COMPOUND, SYMBOL_CONSTANT, SYMBOL_DOTSYMBOL, SYMBOL_DUMMY, SYMBOL_STEM, SYMBOL_VARIABLE, syntaxError(), TOKEN_BLANK, TOKEN_COLON, TOKEN_COMMA, TOKEN_DCOLON, TOKEN_DTILDE, TOKEN_EOC, TOKEN_LEFT, TOKEN_LITERAL, TOKEN_RIGHT, TOKEN_SQLEFT, TOKEN_SQRIGHT, TOKEN_SYMBOL, TOKEN_TILDE, translateChar(), and type.

Referenced by nextClause().

◆ sourceSize()

size_t RexxSource::sourceSize ( )

Definition at line 762 of file SourceFile.cpp.

References line_count, OREF_NULL, reconnect(), sourceArray, and sourceBuffer.

Referenced by builtin_function_SOURCELINE(), and PackageClass::getSourceSize().

◆ startLocation()

void RexxSource::startLocation ( SourceLocation & )

◆ subDirective()

int RexxSource::subDirective ( RexxToken * token )

static

Definition at line 563 of file KeywordConstants.cpp.

References RexxToken::isSymbol(), resolveKeyword(), subDirectives, tabSize, and RexxToken::value.

Referenced by attributeDirective(), classDirective(), libraryDirective(), methodDirective(), optionsDirective(), and routineDirective().

◆ subExpression()

RexxObject * RexxSource::subExpression ( int terminators )

Definition at line 4726 of file SourceFile.cpp.

References RexxToken::classId, collectionMessage(), Error_Invalid_expression_general, Error_Unexpected_comma_bracket, Error_Unexpected_comma_comma, Error_Unexpected_comma_paren, SourceLocation::getLineNumber(), RexxToken::getLocation(), SourceLocation::getOffset(), message(), messageSubterm(), nextReal(), nextToken(), OPERATOR_ABUTTAL, OPERATOR_BACKSLASH, OPERATOR_BLANK, OREF_NULL, popOperator(), popTerm(), precedence(), previousToken(), pushOperator(), pushTerm(), SourceLocation::setEnd(), RexxToken::subclass, syntaxError(), terminator(), TheNilObject, TOKEN_ASSIGNMENT, TOKEN_BLANK, TOKEN_COMMA, TOKEN_DTILDE, TOKEN_LEFT, TOKEN_LITERAL, TOKEN_OPERATOR, TOKEN_RIGHT, TOKEN_SQLEFT, TOKEN_SQRIGHT, TOKEN_SYMBOL, TOKEN_TILDE, and topOperator().

Referenced by argList(), constantExpression(), expression(), instruction(), parenExpression(), and subTerm().

◆ subKeyword()

int RexxSource::subKeyword ( RexxToken * token )

static

Definition at line 468 of file KeywordConstants.cpp.

References RexxToken::isSymbol(), resolveKeyword(), subKeywords, tabSize, and RexxToken::value.

Referenced by addressNew(), callNew(), createDoLoop(), guardNew(), numericNew(), optionsDirective(), parseConditional(), parseNew(), procedureNew(), raiseNew(), RexxInstructionForwardCreate(), selectNew(), signalNew(), terminator(), traceNew(), and useNew().

◆ subTerm()

RexxObject * RexxSource::subTerm ( int terminators )

Definition at line 5278 of file SourceFile.cpp.

References addText(), RexxToken::classId, Error_Invalid_expression_general, Error_Unexpected_comma_bracket, Error_Unexpected_comma_comma, Error_Unexpected_comma_paren, Error_Unmatched_parenthesis_paren, nextToken(), OPERATOR_BACKSLASH, OPERATOR_PLUS, OPERATOR_SUBTRACT, OREF_NULL, previousToken(), RexxToken::subclass, subExpression(), syntaxError(), syntaxErrorAt(), TERM_RIGHT, TERM_SQRIGHT, terminator(), TOKEN_COMMA, TOKEN_LEFT, TOKEN_LITERAL, TOKEN_OPERATOR, TOKEN_RIGHT, TOKEN_SQRIGHT, and TOKEN_SYMBOL.

Referenced by messageSubterm(), and messageTerm().

◆ syntaxError() [1/6]

void RexxSource::syntaxError ( int errorcode )

inline

Definition at line 316 of file SourceFile.hpp.

References error().

◆ syntaxError() [2/6]

void RexxSource::syntaxError	(	int	errorcode,
		RexxInstruction *	i
	)

inline

Definition at line 309 of file SourceFile.hpp.

References errorLine().

Referenced by addressNew(), assignmentNew(), assignmentOpNew(), attributeDirective(), blockError(), callNew(), checkDirective(), checkDuplicateMethod(), classDirective(), comment(), constantDirective(), constantExpression(), constantLogicalExpression(), createDoLoop(), createNativeMethod(), decodeExternalMethod(), directive(), endNew(), getRetriever(), getToken(), guardNew(), ifNew(), instruction(), interpretNew(), isExposeValid(), leaveNew(), libraryDirective(), message(), messageSubterm(), methodDirective(), needVariable(), needVariableOrDotSymbol(), nopNew(), numericNew(), optionsDirective(), optionsNew(), packLiteral(), parseConditional(), parseNew(), procedureNew(), processVariableList(), raiseNew(), requiresDirective(), resolveDependencies(), RexxExpressionLogical::RexxExpressionLogical(), RexxInstructionForwardCreate(), routineDirective(), selectNew(), signalNew(), sourceNextToken(), subExpression(), subTerm(), traceNew(), translate(), translateBlock(), and useNew().

◆ syntaxError() [3/6]

void RexxSource::syntaxError	(	int	errorcode,
		RexxObject *	a1
	)

inline

Definition at line 312 of file SourceFile.hpp.

References error().

◆ syntaxError() [4/6]

void RexxSource::syntaxError	(	int	errorcode,
		RexxObject *	a1,
		RexxObject *	a2
	)

inline

Definition at line 313 of file SourceFile.hpp.

References error().

◆ syntaxError() [5/6]

void RexxSource::syntaxError	(	int	errorcode,
		RexxObject *	a1,
		RexxObject *	a2,
		RexxObject *	a3
	)

inline

Definition at line 314 of file SourceFile.hpp.

References error().

◆ syntaxError() [6/6]

void RexxSource::syntaxError	(	int	errorcode,
		RexxToken *	token
	)

inline

Definition at line 315 of file SourceFile.hpp.

References errorToken().

◆ syntaxErrorAt()

void RexxSource::syntaxErrorAt	(	int	errorcode,
		RexxToken *	token
	)

inline

Definition at line 311 of file SourceFile.hpp.

References errorPosition().

Referenced by argList(), constantExpression(), constantLogicalExpression(), parenExpression(), and subTerm().

◆ terminator() [1/2]

bool RexxSource::terminator	(	int	,
		RexxObject *
	)

Referenced by getToken(), messageSubterm(), subExpression(), and subTerm().

◆ terminator() [2/2]

bool RexxSource::terminator	(	int	terminators,
		RexxToken *	token
	)

Definition at line 412 of file SourceFile.cpp.

References RexxToken::classId, previousToken(), SUBKEY_BY, SUBKEY_FOR, SUBKEY_THEN, SUBKEY_TO, SUBKEY_UNTIL, SUBKEY_WHILE, SUBKEY_WITH, subKeyword(), TERM_BY, TERM_COMMA, TERM_FOR, TERM_KEYWORD, TERM_RIGHT, TERM_SQRIGHT, TERM_THEN, TERM_TO, TERM_WHILE, TERM_WITH, TOKEN_COMMA, TOKEN_EOC, TOKEN_RIGHT, TOKEN_SQRIGHT, and TOKEN_SYMBOL.

◆ thenNew()

RexxInstruction * RexxSource::thenNew	(	RexxToken *	token,
		RexxInstructionIf *	parent
	)

Definition at line 2259 of file InstructionParser.cpp.

References new_instruction.

Referenced by translateBlock().

◆ topDo()

RexxInstruction* RexxSource::topDo ( )

inline

Definition at line 288 of file SourceFile.hpp.

References control, and RexxQueue::peek().

Referenced by flushControl(), and translateBlock().

◆ topOperator()

RexxToken* RexxSource::topOperator ( )

inline

Definition at line 298 of file SourceFile.hpp.

References operators, and RexxQueue::peek().

Referenced by subExpression().

◆ toss()

RexxObject * RexxSource::toss ( RexxObject * object )

Definition at line 1305 of file SourceFile.cpp.

References holdObject(), OREF_NULL, RexxIdentityTable::remove(), and savelist.

Referenced by addClause(), instruction(), parseNew(), raiseNew(), and routineDirective().

◆ traceBack()

RexxString * RexxSource::traceBack	(	RexxActivation *	activation,
		SourceLocation &	location,
		size_t	indent,
		bool	trace
	)

Format a source line for tracing

Parameters

activation	The activation of the current running code. This can be null if this is a translation time error.
location	The source line location.
indent	The indentation amount to apply to the trace line
trace	This is a traced line vs. an error line

Returns: A formatted trace line, including headers and indentations.

Definition at line 946 of file SourceFile.cpp.

References RexxActivity::buildMessage(), ActivityManager::currentActivity, extract(), RexxActivation::formatSourcelessTraceLine(), SourceLocation::getLineNumber(), INDENT_SPACING, INSTRUCTION_OVERHEAD, isInternalCode(), RexxInternalObject::isOldSpace(), line, LINENUMBER, Message_Translations_internal_code, Message_Translations_no_source_available, new_array(), OREF_NULL, PREFIX_LENGTH, PREFIX_OFFSET, programName, RexxString::put(), raw_string(), and RexxString::set().

Referenced by createStackFrame(), and RexxActivation::formatTrace().

◆ traceNew()

RexxInstruction * RexxSource::traceNew ( )

◆ translate()

RexxCode * RexxSource::translate ( RexxDirectory * _labels )

Definition at line 1753 of file SourceFile.cpp.

References _interpret, active_class, atEnd(), class_dependencies, classes, ActivityManager::currentActivity, Numerics::DEFAULT_DIGITS, Numerics::DEFAULT_FORM, Numerics::DEFAULT_FUZZ, RexxActivation::default_trace_flags, DEFAULT_TRACE_SETTING, digits, directive(), Error_Translation_directive_interpret, flags, form, fuzz, initCode, libraries, methods, new_directory(), new_list(), nextClause(), OREF_NULL, OrefSet, public_routines, requires, resolveDependencies(), routines, syntaxError(), traceFlags, traceSetting, and translateBlock().

Referenced by generateCode(), and interpretMethod().

◆ translateBlock()

RexxCode * RexxSource::translateBlock ( RexxDirectory * _labels )

Definition at line 3506 of file SourceFile.cpp.

References _interpret, addClause(), blockSyntaxError(), calls, currentstack, Error_Incomplete_do_else, Error_Incomplete_do_then, Error_Then_expected_if, Error_Unexpected_end_else, Error_Unexpected_end_nodo, Error_Unexpected_end_then, Error_Unexpected_then_else, Error_Unexpected_when_otherwise, Error_Unexpected_when_when, Error_When_expected_whenotherwise, exposed_variables, first, FIRST_VARIABLE_INDEX, flags, flushControl(), RexxInstruction::getType(), guard_variables, instruction(), RexxToken::isEndOfClause(), isOfClass, RexxToken::isSymbol(), RexxDirectory::items(), keyword(), KEYWORD_DO, KEYWORD_ELSE, KEYWORD_END, KEYWORD_ENDTHEN, KEYWORD_ENDWHEN, KEYWORD_FIRST, KEYWORD_IF, KEYWORD_IFTHEN, KEYWORD_LABEL, KEYWORD_LOOP, KEYWORD_OTHERWISE, KEYWORD_SELECT, KEYWORD_THEN, KEYWORD_WHEN, KEYWORD_WHENTHEN, labels, last, maxstack, new_directory(), new_list(), nextClause(), RexxInstruction::nextInstruction, nextReal(), no_clause, OREF_NULL, OrefSet, popDo(), previousToken(), pushDo(), RexxList::removeFirst(), syntaxError(), TheCommonRetrievers, TheNilObject, thenNew(), topDo(), trimClause(), type, variableindex, and variables.

Referenced by createMethod(), methodDirective(), routineDirective(), and translate().

◆ translateChar()

static int RexxSource::translateChar ( char ch )

inlinestatic

Definition at line 381 of file SourceFile.hpp.

References characterTable.

Referenced by RexxVariableDictionary::getDirectVariableRetriever(), and sourceNextToken().

◆ trimClause()

void RexxSource::trimClause ( )

inline

Definition at line 306 of file SourceFile.hpp.

References clause, and RexxClause::trim().

Referenced by instruction(), and translateBlock().

◆ useNew()

RexxInstruction * RexxSource::useNew ( )

Parse a USE STRICT ARG instruction.

Returns: The executable instruction object.

Definition at line 2398 of file InstructionParser.cpp.

References CHAR_ELLIPSIS, RexxToken::classId, constantExpression(), Error_Invalid_expression_use_strict_default, Error_Invalid_subkeyword_use, Error_Translation_use_strict_ellipsis, Error_Variable_expected_USE, Error_Variable_reference_use, RexxToken::isEndOfClause(), RexxToken::isSymbol(), new_queue(), new_variable_instruction, nextReal(), OPERATOR_EQUAL, OREF_NULL, previousToken(), RexxQueue::push(), removeObj(), saveObject(), RexxString::strCompare(), RexxToken::subclass, SUBKEY_ARG, SUBKEY_STRICT, subKeyword(), syntaxError(), TOKEN_COMMA, RexxToken::value, and variableOrMessageTerm().

Referenced by instruction().

◆ variableOrMessageTerm()

RexxObject * RexxSource::variableOrMessageTerm ( )

Parse off a single variable symbol or a message term that can be used for an assignment.

NOTE: If this is a message term, then the message term will be configured as an assignment term.

Returns: The object for an assignment target, or OREF_NULL if something other than a variable or a message term was found. On return, the clause position pointer will either be unchanged or positioned at the next token of the clause.

Definition at line 5134 of file SourceFile.cpp.

References addText(), RexxToken::isSymbol(), messageTerm(), needVariable(), nextReal(), OREF_NULL, and previousToken().

Referenced by parseNew(), and useNew().

◆ words()

RexxArray * RexxSource::words ( RexxString * string )

Definition at line 5438 of file SourceFile.cpp.

References commonString(), RexxString::getLength(), IntegerOne, IntegerTwo, new_array(), new_integer(), RexxQueue::pop(), RexxQueue::push(), RexxArray::put(), subTerms, RexxString::upper(), and RexxString::word().

Referenced by decodeExternalMethod(), and routineDirective().

Friends And Related Function Documentation

◆ RexxActivation

friend class RexxActivation

friend

Definition at line 132 of file SourceFile.hpp.

Member Data Documentation

◆ active_class

ClassDirective* RexxSource::active_class

protected

Definition at line 496 of file SourceFile.hpp.

Referenced by addMethod(), checkDuplicateMethod(), classDirective(), cleanup(), constantDirective(), createConstantGetterMethod(), live(), liveGeneral(), and translate().

◆ builtinFunctions

KeywordEntry RexxSource::builtinFunctions

staticprotected

Definition at line 518 of file SourceFile.hpp.

Referenced by builtin(), and resolveBuiltin().

◆ builtinTable

pbuiltin RexxSource::builtinTable

static

Definition at line 406 of file SourceFile.hpp.

Referenced by RexxExpressionFunction::evaluate(), RexxInstructionCall::execute(), and RexxInstructionCall::trap().

◆ calls

RexxList* RexxSource::calls

protected

Definition at line 507 of file SourceFile.hpp.

Referenced by addReference(), cleanup(), live(), liveGeneral(), and translateBlock().

◆ characterTable

int RexxSource::characterTable

staticprotected

Definition at line 524 of file SourceFile.hpp.

Referenced by isSymbolCharacter(), and translateChar().

◆ class_dependencies

RexxDirectory* RexxSource::class_dependencies

protected

Definition at line 495 of file SourceFile.hpp.

Referenced by classDirective(), cleanup(), live(), liveGeneral(), resolveDependencies(), and translate().

◆ classes

RexxList* RexxSource::classes

protected

Definition at line 466 of file SourceFile.hpp.

Referenced by classDirective(), live(), liveGeneral(), processInstall(), resolveDependencies(), and translate().

◆ clause

RexxClause* RexxSource::clause

protected

Definition at line 447 of file SourceFile.hpp.

Referenced by classDirective(), cleanup(), comment(), firstToken(), globalSetup(), libraryDirective(), live(), liveGeneral(), markPosition(), nextClause(), nextLine(), nextReal(), nextToken(), packLiteral(), previousToken(), requiresDirective(), resetPosition(), sourceNewObject(), sourceNextToken(), and trimClause().

◆ clauseLocation

SourceLocation RexxSource::clauseLocation

protected

Definition at line 448 of file SourceFile.hpp.

Referenced by blockError(), checkDirective(), comment(), createStackFrame(), error(), nextClause(), packLiteral(), resolveDependencies(), and sourceNextToken().

◆ conditionKeywords

KeywordEntry RexxSource::conditionKeywords

staticprotected

Initial value:

= {       
  KeywordEntry(CHAR_ANY,             2601 ),
  KeywordEntry(CHAR_ERROR,           2602 ),
  KeywordEntry(CHAR_FAILURE,         2603 ),
  KeywordEntry(CHAR_HALT,            2604 ),
  KeywordEntry(CHAR_LOSTDIGITS,      2612 ),
  KeywordEntry(CHAR_NOMETHOD,        2605 ),
  KeywordEntry(CHAR_NOSTRING,        2606 ),
  KeywordEntry(CHAR_NOTREADY,        2607 ),
  KeywordEntry(CHAR_NOVALUE,         2608 ),
  KeywordEntry(CHAR_PROPAGATE,       2609 ),
  KeywordEntry(CHAR_SYNTAX,          2610 ),
  KeywordEntry(CHAR_USER,            2611 ),
}

Definition at line 519 of file SourceFile.hpp.

Referenced by condition().

◆ control

RexxQueue* RexxSource::control

protected

Definition at line 491 of file SourceFile.hpp.

Referenced by cleanup(), globalSetup(), live(), liveGeneral(), popDo(), pushDo(), and topDo().

◆ current

const char* RexxSource::current

protected

Definition at line 446 of file SourceFile.hpp.

Referenced by locateToken(), packLiteral(), position(), and sourceNextToken().

◆ current_length

size_t RexxSource::current_length

protected

Definition at line 451 of file SourceFile.hpp.

Referenced by comment(), locateToken(), position(), and sourceNextToken().

◆ currentInstruction

RexxInstruction* RexxSource::currentInstruction

protected

Definition at line 502 of file SourceFile.hpp.

Referenced by cleanup(), live(), liveGeneral(), and sourceNewObject().

◆ currentstack

size_t RexxSource::currentstack

protected

Definition at line 508 of file SourceFile.hpp.

Referenced by popNTerms(), popTerm(), processVariableList(), pushTerm(), and translateBlock().

◆ DEBUG_IGNORE

const size_t RexxSource::DEBUG_IGNORE = 0x0000

static

Definition at line 428 of file SourceFile.hpp.

Referenced by parseTraceSetting(), and RexxActivation::processTraceSetting().

◆ DEBUG_NOTRACE

const size_t RexxSource::DEBUG_NOTRACE = 0x0800

static

Definition at line 432 of file SourceFile.hpp.

Referenced by traceNew().

◆ DEBUG_OFF

const size_t RexxSource::DEBUG_OFF = 0x0200

static

Definition at line 430 of file SourceFile.hpp.

Referenced by parseTraceSetting(), and RexxActivation::processTraceSetting().

◆ DEBUG_ON

const size_t RexxSource::DEBUG_ON = 0x0100

static

Definition at line 429 of file SourceFile.hpp.

Referenced by formatTraceSetting(), RexxActivation::processTraceSetting(), and RexxActivation::setTrace().

◆ DEBUG_TOGGLE

const size_t RexxSource::DEBUG_TOGGLE = 0x0400

static

Definition at line 431 of file SourceFile.hpp.

Referenced by parseTraceSetting(), RexxActivation::processTraceSetting(), and RexxActivation::setTrace().

◆ DEFAULT_TRACE_SETTING

const size_t RexxSource::DEFAULT_TRACE_SETTING = TRACE_NORMAL

static

Definition at line 419 of file SourceFile.hpp.

Referenced by translate().

◆ digits

size_t RexxSource::digits

protected

Definition at line 475 of file SourceFile.hpp.

Referenced by getDigits(), optionsDirective(), and translate().

◆ directives

KeywordEntry RexxSource::directives

staticprotected

Initial value:

= {              
    KeywordEntry(CHAR_ATTRIBUTE,    2405 ),
    KeywordEntry(CHAR_CLASS,        2402 ),
    KeywordEntry(CHAR_CONSTANT,     2406 ),
    KeywordEntry(CHAR_METHOD,       2403 ),
    KeywordEntry(CHAR_OPTIONS,      2407 ),
    KeywordEntry(CHAR_REQUIRES,     2401 ),
    KeywordEntry(CHAR_ROUTINE,      2404 ),
}

Definition at line 515 of file SourceFile.hpp.

Referenced by keyDirective().

◆ exposed_variables

RexxDirectory* RexxSource::exposed_variables

protected

Definition at line 506 of file SourceFile.hpp.

Referenced by addStem(), addVariable(), cleanup(), expose(), live(), liveGeneral(), and translateBlock().

◆ first

RexxInstruction* RexxSource::first

protected

Definition at line 500 of file SourceFile.hpp.

Referenced by addClause(), cleanup(), live(), liveGeneral(), and translateBlock().

◆ flags

size_t RexxSource::flags

protected

Definition at line 439 of file SourceFile.hpp.

Referenced by addStem(), addVariable(), atEnd(), callNew(), checkDirective(), classDirective(), directive(), hasBody(), instruction(), interpretMethod(), isExposeValid(), isInterpret(), libraryDirective(), liveGeneral(), needsInstallation(), nextClause(), processInstall(), reclaimClause(), reconnect(), requiresDirective(), routineDirective(), setReconnect(), translate(), and translateBlock().

◆ form

bool RexxSource::form

protected

Definition at line 477 of file SourceFile.hpp.

Referenced by getForm(), optionsDirective(), and translate().

◆ fuzz

size_t RexxSource::fuzz

protected

Definition at line 476 of file SourceFile.hpp.

Referenced by getFuzz(), optionsDirective(), and translate().

◆ guard_variables

RexxIdentityTable* RexxSource::guard_variables

protected

Definition at line 505 of file SourceFile.hpp.

Referenced by addStem(), addVariable(), cleanup(), getGuard(), live(), liveGeneral(), setGuard(), and translateBlock().

◆ holdstack

RexxStack* RexxSource::holdstack

protected

Definition at line 488 of file SourceFile.hpp.

Referenced by cleanup(), globalSetup(), holdObject(), live(), and liveGeneral().

◆ initCode

RexxCode* RexxSource::initCode

protected

Definition at line 457 of file SourceFile.hpp.

Referenced by live(), liveGeneral(), and translate().

◆ installed_classes

RexxDirectory* RexxSource::installed_classes

protected

Definition at line 469 of file SourceFile.hpp.

Referenced by addInstalledClass(), findInstalledClass(), getInstalledClasses(), live(), liveGeneral(), and processInstall().

◆ installed_public_classes

RexxDirectory* RexxSource::installed_public_classes

protected

Definition at line 468 of file SourceFile.hpp.

Referenced by addInstalledClass(), getInstalledPublicClasses(), live(), liveGeneral(), mergeRequired(), and processInstall().

◆ interpret_adjust

size_t RexxSource::interpret_adjust

protected

Definition at line 455 of file SourceFile.hpp.

Referenced by extract(), extractSource(), interpretLine(), and position().

◆ keywordInstructions

KeywordEntry RexxSource::keywordInstructions

staticprotected

Definition at line 516 of file SourceFile.hpp.

Referenced by keyword().

◆ labels

RexxDirectory* RexxSource::labels

protected

Definition at line 504 of file SourceFile.hpp.

Referenced by addLabel(), cleanup(), findLabel(), live(), liveGeneral(), and translateBlock().

◆ last

RexxInstruction* RexxSource::last

protected

Definition at line 501 of file SourceFile.hpp.

Referenced by addClause(), blockError(), cleanup(), isExposeValid(), live(), liveGeneral(), and translateBlock().

◆ libraries

RexxList* RexxSource::libraries

protected

Definition at line 464 of file SourceFile.hpp.

Referenced by libraryDirective(), live(), liveGeneral(), processInstall(), resolveDependencies(), and translate().

◆ line_count

size_t RexxSource::line_count

protected

Definition at line 452 of file SourceFile.hpp.

Referenced by atEnd(), comment(), extract(), extractSource(), get(), initBuffered(), interpretLine(), locateToken(), position(), RexxSource(), and sourceSize().

◆ line_number

size_t RexxSource::line_number

protected

Definition at line 453 of file SourceFile.hpp.

Referenced by atEnd(), comment(), endLocation(), interpretLine(), locateToken(), nextClause(), nextLine(), position(), and sourceNextToken().

◆ line_offset

size_t RexxSource::line_offset

protected

Definition at line 454 of file SourceFile.hpp.

Referenced by comment(), endLocation(), locateToken(), nextClause(), nextLine(), nextSpecial(), position(), and sourceNextToken().

◆ literals

RexxDirectory* RexxSource::literals

protected

Definition at line 489 of file SourceFile.hpp.

Referenced by addText(), cleanup(), globalSetup(), live(), and liveGeneral().

◆ loadedPackages

RexxList* RexxSource::loadedPackages

protected

Definition at line 459 of file SourceFile.hpp.

Referenced by addPackage(), getPackages(), live(), and liveGeneral().

◆ maxstack

size_t RexxSource::maxstack

protected

Definition at line 509 of file SourceFile.hpp.

Referenced by pushTerm(), and translateBlock().

◆ merged_public_classes

RexxDirectory* RexxSource::merged_public_classes

protected

Definition at line 470 of file SourceFile.hpp.

Referenced by findPublicClass(), getImportedClasses(), live(), liveGeneral(), and mergeRequired().

◆ merged_public_routines

RexxDirectory* RexxSource::merged_public_routines

protected

Definition at line 472 of file SourceFile.hpp.

Referenced by findPublicRoutine(), getImportedRoutines(), live(), liveGeneral(), and mergeRequired().

◆ methods

RexxDirectory* RexxSource::methods

protected

Definition at line 473 of file SourceFile.hpp.

Referenced by addMethod(), checkDuplicateMethod(), getDefinedMethods(), getMethods(), live(), liveGeneral(), resolveDependencies(), and translate().

◆ operators

RexxQueue* RexxSource::operators

protected

Definition at line 494 of file SourceFile.hpp.

Referenced by cleanup(), globalSetup(), live(), liveGeneral(), popOperator(), pushOperator(), and topOperator().

◆ package

PackageClass* RexxSource::package

protected

Definition at line 460 of file SourceFile.hpp.

Referenced by getPackage(), live(), and liveGeneral().

◆ parentSource

RexxSource* RexxSource::parentSource

protected

Definition at line 461 of file SourceFile.hpp.

Referenced by findInstalledClass(), findLocalRoutine(), findPublicClass(), findPublicRoutine(), inheritSourceContext(), live(), and liveGeneral().

◆ parseOptions

KeywordEntry RexxSource::parseOptions

staticprotected

Initial value:

= {            
  KeywordEntry(CHAR_ARG,            1 ),
  KeywordEntry(CHAR_CASELESS,                    1  + 1  + 1  + 1  + 1  + 1  + 1  + 1  + 1  + 1  + 1  + 1  + 1  + 1 ),
  KeywordEntry(CHAR_LINEIN,                    1  + 1  + 1  + 1  + 1  + 1  + 1  + 1  + 1  + 1  + 1  + 1 ),
  KeywordEntry(CHAR_LOWER,                      1  + 1  + 1  + 1  + 1  + 1  + 1  + 1  + 1  + 1  + 1  + 1  + 1 ),
  KeywordEntry(CHAR_PULL,                               1  + 1  + 1  + 1  + 1  + 1  + 1  + 1  + 1  + 1  + 1  + 1  + 1  + 1  + 1  + 1  + 1  + 1  + 1  + 1  + 1 ),
  KeywordEntry(CHAR_SOURCE,                               1  + 1  + 1  + 1  + 1  + 1  + 1  + 1  + 1  + 1  + 1  + 1  + 1  + 1  + 1  + 1  + 1  + 1  + 1  + 1  + 1  + 1  + 1 ),
  KeywordEntry(CHAR_UPPER,                                    1  + 1  + 1  + 1  + 1  + 1  + 1  + 1  + 1  + 1  + 1  + 1  + 1  + 1  + 1  + 1  + 1  + 1  + 1  + 1  + 1  + 1  + 1  + 1  + 1  + 1  + 1 ),
  KeywordEntry(CHAR_VALUE,                                     1  + 1  + 1  + 1  + 1  + 1  + 1  + 1  + 1  + 1  + 1  + 1  + 1  + 1  + 1  + 1  + 1  + 1  + 1  + 1  + 1  + 1  + 1  + 1  + 1  + 1  + 1  + 1 ),
  KeywordEntry(CHAR_VAR,                                        1  + 1  + 1  + 1  + 1  + 1  + 1  + 1  + 1  + 1  + 1  + 1  + 1  + 1  + 1  + 1  + 1  + 1  + 1  + 1  + 1  + 1  + 1  + 1  + 1  + 1  + 1  + 1  + 1 ),
  KeywordEntry(CHAR_VERSION,                                     1  + 1  + 1  + 1  + 1  + 1  + 1  + 1  + 1  + 1  + 1  + 1  + 1  + 1  + 1  + 1  + 1  + 1  + 1  + 1  + 1  + 1  + 1  + 1  + 1  + 1  + 1  + 1  + 1  + 1 ),
}

Definition at line 520 of file SourceFile.hpp.

Referenced by parseOption().

◆ programDirectory

RexxString* RexxSource::programDirectory

protected

Definition at line 442 of file SourceFile.hpp.

Referenced by extractNameInformation(), getProgramDirectory(), live(), liveGeneral(), and resolveProgramName().

◆ programExtension

RexxString* RexxSource::programExtension

protected

Definition at line 444 of file SourceFile.hpp.

Referenced by extractNameInformation(), getProgramExtension(), live(), liveGeneral(), and resolveProgramName().

◆ programFile

RexxString* RexxSource::programFile

protected

Definition at line 443 of file SourceFile.hpp.

Referenced by extractNameInformation(), getProgramFile(), live(), and liveGeneral().

◆ programName

RexxString* RexxSource::programName

protected

Definition at line 441 of file SourceFile.hpp.

Referenced by createStackFrame(), extractNameInformation(), getProgramName(), initFile(), install(), interpret(), live(), liveGeneral(), resolveDependencies(), setProgramName(), and traceBack().

◆ public_routines

RexxDirectory* RexxSource::public_routines

protected

Definition at line 463 of file SourceFile.hpp.

Referenced by addInstalledRoutine(), getInstalledPublicRoutines(), getPublicRoutines(), live(), liveGeneral(), mergeRequired(), resolveDependencies(), routineDirective(), setPublicRoutines(), and translate().

◆ requires

RexxList* RexxSource::requires

protected

Definition at line 465 of file SourceFile.hpp.

Referenced by live(), liveGeneral(), processInstall(), requiresDirective(), resolveDependencies(), and translate().

◆ reserved1

intptr_t RexxSource::reserved1

protected

Definition at line 480 of file SourceFile.hpp.

◆ reserved2

intptr_t RexxSource::reserved2

protected

Definition at line 481 of file SourceFile.hpp.

◆ reserved3

intptr_t RexxSource::reserved3

protected

Definition at line 482 of file SourceFile.hpp.

◆ reserved4

intptr_t RexxSource::reserved4

protected

Definition at line 483 of file SourceFile.hpp.

◆ routines

RexxDirectory* RexxSource::routines

protected

Definition at line 462 of file SourceFile.hpp.

Referenced by addInstalledRoutine(), findLocalRoutine(), getInstalledRoutines(), getLocalRoutines(), getRoutines(), live(), liveGeneral(), resolveDependencies(), routineDirective(), setLocalRoutines(), and translate().

◆ savelist

RexxIdentityTable* RexxSource::savelist

protected

Definition at line 487 of file SourceFile.hpp.

Referenced by cleanup(), globalSetup(), live(), liveGeneral(), removeObj(), saveObject(), and toss().

◆ securityManager

SecurityManager* RexxSource::securityManager

protected

Definition at line 445 of file SourceFile.hpp.

Referenced by findClass(), flatten(), getSecurityManager(), live(), liveGeneral(), and setSecurityManager().

◆ sourceArray

RexxArray* RexxSource::sourceArray

protected

Definition at line 440 of file SourceFile.hpp.

Referenced by extract(), extractSource(), flatten(), get(), isTraceable(), live(), liveGeneral(), position(), RexxSource(), and sourceSize().

◆ sourceBuffer

RexxBuffer* RexxSource::sourceBuffer

protected

Definition at line 449 of file SourceFile.hpp.

Referenced by extract(), extractSource(), flatten(), get(), initBuffered(), initFile(), isTraceable(), live(), liveGeneral(), position(), and sourceSize().

◆ sourceIndices

RexxBuffer* RexxSource::sourceIndices

protected

Definition at line 450 of file SourceFile.hpp.

Referenced by flatten(), get(), initBuffered(), live(), liveGeneral(), and position().

◆ strings

RexxDirectory* RexxSource::strings

protected

Definition at line 490 of file SourceFile.hpp.

Referenced by cleanup(), commonString(), globalSetup(), live(), and liveGeneral().

◆ subDirectives

KeywordEntry RexxSource::subDirectives

staticprotected

Initial value:

= {           
    KeywordEntry(CHAR_ABSTRACT,     2513 ),
    KeywordEntry(CHAR_ATTRIBUTE,    2511 ),
    KeywordEntry(CHAR_CLASS,        2506 ),
    KeywordEntry(CHAR_DIGITS,       2518 ),
    KeywordEntry(CHAR_EXTERNAL,     2507 ),
    KeywordEntry(CHAR_FORM,         2519 ),
    KeywordEntry(CHAR_FUZZ,         2520 ),
    KeywordEntry(CHAR_GET,          2515 ),
    KeywordEntry(CHAR_GUARDED,      2505 ),
    KeywordEntry(CHAR_INHERIT,      2503 ),
    KeywordEntry(CHAR_LIBRARY,      2517 ),
    KeywordEntry(CHAR_METACLASS,    2502 ),
    KeywordEntry(CHAR_MIXINCLASS,   2510 ),
    KeywordEntry(CHAR_PRIVATE,      2504 ),
    KeywordEntry(CHAR_PROTECTED,    2512 ),
    KeywordEntry(CHAR_PUBLIC,       2501 ),
    KeywordEntry(CHAR_SET,          2516 ),
    KeywordEntry(CHAR_SUBCLASS,     2508 ),
    KeywordEntry(CHAR_TRACE,        2521 ),
    KeywordEntry(CHAR_UNGUARDED,    2509 ),
    KeywordEntry(CHAR_UNPROTECTED,  2514 ),
}

Definition at line 521 of file SourceFile.hpp.

Referenced by subDirective().

◆ subKeywords

KeywordEntry RexxSource::subKeywords

staticprotected

Definition at line 517 of file SourceFile.hpp.

Referenced by subKeyword().

◆ subTerms

RexxQueue* RexxSource::subTerms

protected

Definition at line 493 of file SourceFile.hpp.

Referenced by addCompound(), argArray(), argList(), callNew(), cleanup(), collectionMessage(), dropNew(), exposeNew(), globalSetup(), live(), liveGeneral(), message(), parseLogical(), parseNew(), procedureNew(), processVariableList(), raiseNew(), and words().

◆ terms

RexxQueue* RexxSource::terms

protected

Definition at line 492 of file SourceFile.hpp.

Referenced by cleanup(), globalSetup(), live(), liveGeneral(), parseNew(), popNTerms(), popTerm(), and pushTerm().

◆ TRACE_ALL

const size_t RexxSource::TRACE_ALL = 'A'

static

Definition at line 408 of file SourceFile.hpp.

Referenced by parseTraceSetting(), and RexxActivation::processTraceSetting().

◆ TRACE_COMMANDS

const size_t RexxSource::TRACE_COMMANDS = 'C'

static

Definition at line 409 of file SourceFile.hpp.

Referenced by parseTraceSetting(), and RexxActivation::processTraceSetting().

◆ TRACE_DEBUG_MASK

const size_t RexxSource::TRACE_DEBUG_MASK = 0xff00

static

Definition at line 435 of file SourceFile.hpp.

◆ TRACE_ERRORS

const size_t RexxSource::TRACE_ERRORS = 'E'

static

Definition at line 413 of file SourceFile.hpp.

Referenced by parseTraceSetting(), and RexxActivation::processTraceSetting().

◆ TRACE_FAILURES

const size_t RexxSource::TRACE_FAILURES = 'F'

static

Definition at line 412 of file SourceFile.hpp.

Referenced by parseTraceSetting(), and RexxActivation::processTraceSetting().

◆ TRACE_IGNORE

const size_t RexxSource::TRACE_IGNORE = '0'

static

Definition at line 417 of file SourceFile.hpp.

Referenced by parseTraceSetting(), and RexxActivation::processTraceSetting().

◆ TRACE_INTERMEDIATES

const size_t RexxSource::TRACE_INTERMEDIATES = 'I'

static

Definition at line 415 of file SourceFile.hpp.

Referenced by parseTraceSetting(), and RexxActivation::processTraceSetting().

◆ TRACE_LABELS

const size_t RexxSource::TRACE_LABELS = 'L'

static

Definition at line 410 of file SourceFile.hpp.

Referenced by parseTraceSetting(), and RexxActivation::processTraceSetting().

◆ TRACE_NORMAL

const size_t RexxSource::TRACE_NORMAL = 'N'

static

Definition at line 411 of file SourceFile.hpp.

Referenced by parseTraceSetting(), RexxActivation::processTraceSetting(), and traceNew().

◆ TRACE_OFF

const size_t RexxSource::TRACE_OFF = 'O'

static

Definition at line 416 of file SourceFile.hpp.

Referenced by parseTraceSetting(), and RexxActivation::processTraceSetting().

◆ TRACE_RESULTS

const size_t RexxSource::TRACE_RESULTS = 'R'

static

Definition at line 414 of file SourceFile.hpp.

Referenced by parseTraceSetting(), and RexxActivation::processTraceSetting().

◆ TRACE_SETTING_MASK

const size_t RexxSource::TRACE_SETTING_MASK = 0xff

static

Definition at line 422 of file SourceFile.hpp.

Referenced by formatTraceSetting(), and RexxActivation::processTraceSetting().

◆ traceFlags

size_t RexxSource::traceFlags

protected

Definition at line 479 of file SourceFile.hpp.

Referenced by getTraceFlags(), optionsDirective(), and translate().

◆ traceSetting

size_t RexxSource::traceSetting

protected

Definition at line 478 of file SourceFile.hpp.

Referenced by getTrace(), getTraceSetting(), optionsDirective(), and translate().

◆ variableindex

size_t RexxSource::variableindex

protected

Definition at line 510 of file SourceFile.hpp.

Referenced by addStem(), addVariable(), and translateBlock().

◆ variables

RexxDirectory* RexxSource::variables

protected

Definition at line 503 of file SourceFile.hpp.

Referenced by addStem(), addText(), addVariable(), cleanup(), live(), liveGeneral(), and translateBlock().

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

interpreter/parser/SourceFile.hpp
interpreter/expression/BuiltinFunctions.cpp
interpreter/parser/InstructionParser.cpp
interpreter/parser/KeywordConstants.cpp
interpreter/parser/Scanner.cpp
interpreter/parser/SourceFile.cpp

Public Member Functions

Static Public Member Functions

Static Public Attributes

Protected Attributes

Static Protected Attributes

Friends

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ RexxSource() [1/5]

◆ RexxSource() [2/5]

◆ RexxSource() [3/5]

◆ RexxSource() [4/5]

◆ RexxSource() [5/5]

Member Function Documentation

◆ addBlock()

◆ addClause()

◆ addCompound()

◆ addInstalledClass()

◆ addInstalledRoutine()

◆ addLabel()

◆ addMethod()

◆ addPackage()

◆ addReference()

◆ addressNew()

◆ addStem()

◆ addText()

◆ addVariable() [1/2]

◆ addVariable() [2/2]

◆ argArray()

◆ argList()

◆ assignmentNew()

◆ assignmentOpNew()

◆ atEnd()

◆ attributeDirective()

◆ blockError()

◆ blockSyntaxError()

◆ builtin()

◆ callNew()

◆ checkDirective()

◆ checkDuplicateMethod()

◆ classDirective()

◆ cleanup()

◆ collectionMessage()

◆ commandNew()

◆ comment()

◆ commonString()

◆ condition()

◆ constantDirective()

◆ constantExpression()

◆ constantLogicalExpression()

◆ createAbstractMethod()

◆ createAttributeGetterMethod()

◆ createAttributeSetterMethod()

◆ createConstantGetterMethod()

◆ createDoLoop() [1/2]

◆ createDoLoop() [2/2]

◆ createLoop()

◆ createMethod()

◆ createNativeMethod()

◆ createStackFrame()

◆ decodeExternalMethod()

◆ directive()

◆ doNew()

◆ dropNew()

◆ elseNew()

◆ endIfNew()

◆ endLocation()

◆ endNew()

◆ error() [1/5]

◆ error() [2/5]

◆ error() [3/5]

◆ error() [4/5]

◆ error() [5/5]

◆ errorCleanup()

◆ errorLine()

◆ errorPosition()

◆ errorToken()

◆ exitNew()

◆ expose()