Public Member Functions | Static Public Member Functions | Static Public Attributes | Protected Attributes | Static Protected Attributes | Friends | List of all members
RexxSource Class Reference

#include <SourceFile.hpp>

Inheritance diagram for RexxSource:
[legend]

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 setIsBlock (bool b)
 
bool getIsBlock ()
 
void initBuffered (RexxBuffer *)
 
void initFile ()
 
void extractNameInformation ()
 
bool reconnect ()
 
void setReconnect ()
 
void setBufferedSource (RexxBuffer *newSource)
 
void interpretLine (size_t)
 
void adjustLine (size_t, 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 *)
 
RexxToken * sourceLiteral (size_t, SourceLocation)
 
RexxString * traceBack (RexxActivation *, SourceLocation &, size_t, bool)
 
RexxString * extract (SourceLocation &, bool=false)
 
RexxArray * extractSource (SourceLocation &)
 
RexxArray * extractSource ()
 
void startLocation (SourceLocation &)
 
void endLocation (SourceLocation &)
 
bool nextSpecial (unsigned int, SourceLocation &, bool advance=true)
 
unsigned int locateToken (RexxToken *)
 
void globalSetup ()
 
RexxString * packLiteral (size_t, size_t, int)
 
RexxCode * generateCode (bool isMethod)
 
RexxCode * interpretMethod (RexxDirectory *, RexxActivation *)
 
RexxCode * interpret (RexxString *, RexxDirectory *, size_t, RexxActivation *)
 
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 extensionDirective ()
 
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, AccessFlag privateMethod, ProtectedFlag protectedMethod, GuardFlag guardedMethod, bool isAttribute)
 
void createAttributeGetterMethod (RexxString *name, RexxVariableBase *retriever, bool classMethod, AccessFlag privateMethod, ProtectedFlag protectedMethod, GuardFlag guardedMethod)
 
void createAttributeSetterMethod (RexxString *name, RexxVariableBase *retriever, bool classMethod, AccessFlag privateMethod, ProtectedFlag protectedMethod, GuardFlag guardedMethod)
 
void createConstantGetterMethod (RexxString *name, RexxObject *value)
 
void createAbstractMethod (RexxString *name, bool classMethod, AccessFlag privateMethod, ProtectedFlag protectedMethod, GuardFlag guardedMethod, bool isAttribute)
 
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)
 
RexxObject * fullSubExpression (int)
 
void argList (RexxToken *, int, bool, size_t &, size_t &)
 
void argArray (RexxToken *, int, bool, RexxArray *&, RexxArray *&)
 
RexxObject * function (RexxToken *, RexxToken *, int)
 
RexxObject * functionCallMessage (RexxToken *, RexxObject *, 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 *)
 
void pushSubTerm (RexxObject *)
 
RexxObject * popTerm ()
 
RexxObject * popSubTerm ()
 
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, SourceLocation)
 
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 syntaxErrorAt (int errorcode, SourceLocation token_location)
 
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 * upperNew ()
 
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 ()
 
bool getEnableCommands ()
 
bool getEnableMacrospace ()
 
- Public Member Functions inherited from RexxInternalObject
void * operator new (size_t, RexxClass *)
 
void * operator new (size_t, RexxClass *, RexxObject **, size_t, size_t)
 
void * operator new (size_t size, void *ptr)
 
void operator delete (void *)
 
void operator delete (void *p, void *ptr)
 
 RexxInternalObject ()
 
 RexxInternalObject (RESTORETYPE restoreType)
 
virtual ~RexxInternalObject ()
 
 operator RexxObject * ()
 
size_t getObjectSize ()
 
void setObjectSize (size_t s)
 
size_t getObjectDataSize ()
 
void * getObjectDataSpace ()
 
void clearObject ()
 
void clearObject (size_t l)
 
void setVirtualFunctions (void *t)
 
void setInitHeader (size_t s, size_t markword)
 
void setInitHeader (size_t markword)
 
void setObjectLive (size_t markword)
 
void setHasReferences ()
 
void setHasNoReferences ()
 
bool hasReferences ()
 
bool hasNoReferences ()
 
void setPrimitive ()
 
void setNonPrimitive ()
 
bool isPrimitive ()
 
bool isNonPrimitive ()
 
void setInRexxPackage ()
 
bool isInRexxPackage ()
 
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 RexxText * makeText ()
 
virtual void copyIntoTail (RexxCompoundTail *buffer)
 
virtual RexxString * primitiveMakeString ()
 
virtual RexxText * primitiveMakeText ()
 
virtual RexxArray * makeArray ()
 
virtual RexxString * stringValue ()
 
virtual RexxText * textValue ()
 
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 *)
 
virtual RexxObject * dynamicTarget (RexxObject **arguments, size_t count, size_t named_count)
 
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 (codepoint_t ch)
 
static int translateChar (codepoint_t 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 line_adjust
 
RexxActivation * interpret_activation
 
RexxCode * initCode
 
RexxList * loadedPackages
 
PackageClass * package
 
RexxSource * parentSource
 
bool isBlock
 
RexxDirectory * routines
 
RexxDirectory * public_routines
 
RexxList * libraries
 
RexxList * requires
 
RexxList * classes
 
RexxList * extensions
 
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
 
bool enableCommands
 
bool enableMacrospace
 
intptr_t reserved1
 
intptr_t reserved2
 
intptr_t reserved3
 
intptr_t reserved4
 
RexxIdentityTable * savelist
 
RexxStack * holdstack
 
RexxDirectory * literals
 
RexxList * sourceLiterals
 
RexxDirectory * strings
 
RexxQueue * control
 
RexxQueue * terms
 
RexxQueue * subTerms
 
RexxQueue * namedSubTerms
 
RexxQueue * operators
 
RexxDirectory * class_dependencies
 
ClassDirective * active_class
 
ExtensionDirective * active_extension
 
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 133 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
programnameThe name of the program.
source_arrayThe array of the source lines.

Definition at line 113 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
programnameThe name of the program.
source_bufferThe source buffer holding the source data.

Definition at line 133 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
programnameThe name of the program.
dataThe data buffer pointer.
lengththe size of the source buffer.

Definition at line 153 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
programnameThe name of the program (also the file name)

Definition at line 170 of file SourceFile.cpp.

References initFile(), and setProgramName().

◆ RexxSource() [5/5]

RexxSource::RexxSource ( RESTORETYPE  restoreType)
inline

Definition at line 144 of file SourceFile.hpp.

Member Function Documentation

◆ addBlock()

void RexxSource::addBlock ( void  )

◆ addClause()

void RexxSource::addClause ( RexxInstruction *  _instruction)

Definition at line 4951 of file SourceFile.cpp.

References ConcurrencyInfos::activation, CONCURRENCY_TRACE, dbgprintf(), extract(), first, Utilities::GetConcurrencyInfos(), SourceLocation::getEndLine(), SourceLocation::getEndOffset(), SourceLocation::getLineNumber(), SourceLocation::getOffset(), RexxString::getStringData(), RexxInstruction::instructionFlags, RexxInstruction::instructionLocation, RexxInstruction::instructionType, RexxToken::keywordText(), last, ConcurrencyInfos::lock, OREF_NULL, OrefSet, ConcurrencyInfos::reserveCount, RexxInstruction::setNext(), ConcurrencyInfos::threadId, toss(), Utilities::traceConcurrency(), Utilities::traceParsing(), and ConcurrencyInfos::variableDictionary.

Referenced by flushControl(), and translateBlock().

◆ addCompound()

RexxCompoundVariable * RexxSource::addCompound ( RexxString *  name)

Definition at line 4673 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
nameThe class name
classObjectThe class object
publicClassIndicates whether this needs to be added to the public list as well.

Definition at line 7012 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
nameThe routine name
classObjectThe routine object
publicClassIndicates whether this needs to be added to the public list as well.

Definition at line 7043 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 5009 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
nameThe directory name of the method.
methodThe method object.
classMethodThe class/instance method indicator.

Definition at line 2360 of file SourceFile.cpp.

References active_class, active_extension, ClassDirective::addMethod(), ExtensionDirective::addMethod(), methods, OREF_NULL, RexxDirectory::setEntry(), and BaseExecutable::setSourceObject().

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 6963 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 296 of file SourceFile.hpp.

References RexxList::addLast(), and calls.

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

◆ addressNew()

RexxInstruction * RexxSource::addressNew ( )

Definition at line 111 of file InstructionParser.cpp.

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

Referenced by instruction().

◆ addStem()

RexxStemVariable * RexxSource::addStem ( RexxString *  stemName)

Definition at line 4636 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)

Definition at line 4785 of file SourceFile.cpp.

References addCompound(), addStem(), addVariable(), RexxList::append(), RexxToken::classId, commonString(), Numerics::DEFAULT_DIGITS, RexxString::extract(), RexxDirectory::fastAt(), RexxString::getLength(), SourceLocation::getLineNumber(), RexxString::getStringData(), INTEGER_CONSTANT, literals, new_string(), RexxObject::numberString(), RexxToken::numeric, OREF_NULL, package, RexxDirectory::put(), RexxObject::requestInteger(), RexxString::setNumberString(), sourceLiterals, RexxToken::subclass, SYMBOL_COMPOUND, SYMBOL_CONSTANT, SYMBOL_DOTSYMBOL, SYMBOL_DUMMY, SYMBOL_STEM, SYMBOL_VARIABLE, TheNilObject, TOKEN_LITERAL, TOKEN_SOURCE_LITERAL, TOKEN_SYMBOL, RexxToken::tokenLocation, RexxToken::value, and variables.

Referenced by addVariable(), argList(), assignmentNew(), assignmentOpNew(), constantExpression(), constantLogicalExpression(), message(), parseNew(), processVariableList(), subTerm(), and variableOrMessageTerm().

◆ addVariable() [1/2]

RexxVariableBase * RexxSource::addVariable ( RexxString *  varname)

Definition at line 4599 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 4778 of file SourceFile.cpp.

References addText(), and needVariable().

◆ adjustLine()

void RexxSource::adjustLine ( size_t  start_line_number,
size_t  end_line_number 
)

Definition at line 365 of file SourceFile.cpp.

References line_adjust, line_count, and line_number.

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

◆ argArray()

void RexxSource::argArray ( RexxToken *  _first,
int  terminators,
bool  namedArgumentAllowed,
RexxArray *&  _argArray,
RexxArray *&  _namedArgArray 
)

Definition at line 5447 of file SourceFile.cpp.

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

Referenced by RexxInstructionForwardCreate().

◆ argList()

void RexxSource::argList ( RexxToken *  _first,
int  terminators,
bool  namedArgumentAllowed,
size_t &  positionalArgumentCount,
size_t &  namedArgumentCount 
)

Definition at line 5487 of file SourceFile.cpp.

References addText(), RexxToken::classId, RexxString::concatToCstring(), RexxString::concatWithCstring(), Error_Translation_user_defined, Error_Unmatched_parenthesis_paren, Error_Unmatched_parenthesis_square, RexxList::hasItem(), IntegerOne, RexxToken::isEndOfClause(), RexxToken::isSourceLiteral(), markPosition(), namedSubTerms, needVariable(), new_queue(), new_string(), nextReal(), nextToken(), OREF_NULL, RexxQueue::pop(), popNTerms(), position(), previousToken(), RexxQueue::push(), pushTerm(), resetPosition(), subExpression(), subTerms, syntaxError(), syntaxErrorAt(), TERM_COMMA, TERM_RIGHT, TERM_SQRIGHT, terminator(), TheTrueObject, TOKEN_COLON, TOKEN_COMMA, TOKEN_RIGHT, TOKEN_SQRIGHT, TOKEN_SYMBOL, and RexxToken::value.

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

◆ assignmentNew()

RexxInstruction * RexxSource::assignmentNew ( RexxToken *  target)

Definition at line 166 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
targetThe assignment target variable.
operationThe operator token. classId is TOKEN_ASSIGNMENT, the subclass is the type of the operation to perform.
Returns
The constructed instruction object.

Definition at line 198 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 311 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 2907 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(), IS_SUBDIRECTIVE, RexxToken::isEndOfClause(), RexxToken::isLiteral(), RexxToken::isSymbol(), RexxToken::isSymbolOrLiteral(), nextReal(), OREF_NULL, PACKAGE_SCOPE, PRIVATE_SCOPE, PROTECTED_METHOD, PUBLIC_SCOPE, refineSubclass, RexxMethod::setAttribute(), RexxMethod::setAttributes(), subDirective(), SUBDIRECTIVE_ABSTRACT, SUBDIRECTIVE_CLASS, SUBDIRECTIVE_EXTERNAL, SUBDIRECTIVE_GET, SUBDIRECTIVE_GUARDED, SUBDIRECTIVE_PACKAGE, 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 6462 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 321 of file SourceFile.hpp.

References blockError().

Referenced by translateBlock().

◆ builtin()

int RexxSource::builtin ( RexxToken *  token)
static

Definition at line 507 of file KeywordConstants.cpp.

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

Referenced by callNew().

◆ callNew()

RexxInstruction * RexxSource::callNew ( )

Definition at line 219 of file InstructionParser.cpp.

References addReference(), argList(), builtin(), RexxInstructionCall::call_dynamic, RexxInstructionCall::call_nointernal, RexxInstructionCall::call_on_off, RexxToken::classId, commonString(), 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, IS_BUILTIN, IS_CONDITION, IS_SUBKEY, RexxToken::isEndOfClause(), RexxToken::isLiteral(), RexxToken::isSymbol(), namedSubTerms, new_variable_instruction, nextReal(), OREF_NULL, parenExpression(), refineSubclass, 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 1357 of file SourceFile.cpp.

References RexxToken::classId, clause, clauseLocation, dumpClause, 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
nameThe name to check.
classMethodIndicates whether this is a check for a CLASS or INSTANCE method.
errorMsgThe error code to use if there is a duplicate.

Definition at line 2316 of file SourceFile.cpp.

References active_class, active_extension, ClassDirective::checkDuplicateMethod(), ExtensionDirective::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 2056 of file SourceFile.cpp.

References _install, active_class, active_extension, 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(), IS_SUBDIRECTIVE, RexxToken::isEndOfClause(), RexxToken::isSymbol(), RexxToken::isSymbolOrLiteral(), nextReal(), OREF_NULL, OrefSet, previousToken(), PRIVATE_SCOPE, PUBLIC_SCOPE, RexxDirectory::put(), refineSubclass, subDirective(), SUBDIRECTIVE_ABSTRACT, 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 1432 of file SourceFile.cpp.

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

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

◆ collectionMessage()

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

Definition at line 5742 of file SourceFile.cpp.

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

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

◆ commandNew()

RexxInstruction * RexxSource::commandNew ( )

Definition at line 446 of file InstructionParser.cpp.

References expression(), new_instruction, and TERM_EOC.

Referenced by instruction().

◆ comment()

void RexxSource::comment ( )

Definition at line 246 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(), SourceLocation::setLimitedTrace(), and syntaxError().

Referenced by locateToken().

◆ commonString()

RexxString * RexxSource::commonString ( RexxString *  string)

Definition at line 4754 of file SourceFile.cpp.

References RexxDirectory::fastAt(), RexxString::getEncoding(), RexxString::getStringData(), RexxString::getText(), OREF_NULL, RexxDirectory::put(), and strings.

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

◆ condition()

int RexxSource::condition ( RexxToken *  token)
static

Definition at line 532 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 3248 of file SourceFile.cpp.

References active_class, checkDirective(), checkDuplicateMethod(), commonString(), RexxString::concat(), 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::isEndOfClause(), RexxToken::isOperator(), 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 5069 of file SourceFile.cpp.

References addText(), RexxToken::classId, Error_Invalid_expression_general, Error_Unmatched_parenthesis_paren, holdObject(), RexxToken::isConstant(), RexxToken::isEndOfClause(), RexxToken::isLiteral(), RexxToken::isSourceLiteral(), 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 5121 of file SourceFile.cpp.

References addText(), RexxToken::classId, Error_Invalid_expression_general, Error_Unmatched_parenthesis_paren, holdObject(), RexxToken::isConstant(), RexxToken::isEndOfClause(), RexxToken::isLiteral(), RexxToken::isSourceLiteral(), 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,
AccessFlag  privateMethod,
ProtectedFlag  protectedMethod,
GuardFlag  guardedMethod,
bool  isAttribute 
)

Create an abstract method.

Parameters
nameThe name of the method.
classMethodIndicates we're adding a class or instance method.
privateMethodThe method's private attribute.
protectedMethodThe method's protected attribute.
guardedMethodThe method's guarded attribute.

Definition at line 3425 of file SourceFile.cpp.

References addMethod(), RexxMethod::setAbstract(), RexxMethod::setAttribute(), RexxMethod::setAttributes(), and BaseExecutable::setSourceObject().

Referenced by attributeDirective().

◆ createAttributeGetterMethod()

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

Create an ATTRIBUTE "get" method.

Parameters
nameThe name of the attribute.
retriever
classMethodIndicates we're adding a class or instance method.
privateMethodThe method's private attribute.
protectedMethodThe method's protected attribute.
guardedMethodThe method's guarded attribute.

Definition at line 3369 of file SourceFile.cpp.

References addMethod(), RexxMethod::setAttribute(), RexxMethod::setAttributes(), and BaseExecutable::setSourceObject().

Referenced by attributeDirective(), and methodDirective().

◆ createAttributeSetterMethod()

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

Create an ATTRIBUTE "set" method.

Parameters
nameThe name of the attribute.
classMethodIndicates we're adding a class or instance method.
privateMethodThe method's private attribute.
protectedMethodThe method's protected attribute.
guardedMethodThe method's guarded attribute.

Definition at line 3397 of file SourceFile.cpp.

References addMethod(), RexxMethod::setAttribute(), RexxMethod::setAttributes(), and BaseExecutable::setSourceObject().

Referenced by attributeDirective(), and methodDirective().

◆ createConstantGetterMethod()

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

Create a CONSTANT "get" method.

Parameters
targetThe target method directory.
nameThe name of the attribute.

Definition at line 3449 of file SourceFile.cpp.

References active_class, active_extension, ClassDirective::addConstantMethod(), ExtensionDirective::addConstantMethod(), addMethod(), OREF_NULL, RexxMethod::setConstant(), BaseExecutable::setSourceObject(), and RexxMethod::setUnguarded().

Referenced by constantDirective().

◆ createDoLoop() [1/2]

RexxInstruction * RexxSource::createDoLoop ( )

Create a DO instruction instance.

Returns

Definition at line 486 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 509 of file InstructionParser.cpp.

References RexxInstructionDo::by, RexxInstructionDo::conditional, RexxInstructionDo::control, CONTROLLED_DO, CONTROLLED_UNTIL, CONTROLLED_WHILE, DO_COUNT, DO_COUNT_UNTIL, DO_COUNT_WHILE, DO_FOREVER, DO_OVER, DO_OVER_UNTIL, DO_OVER_WHILE, DO_UNTIL, DO_WHILE, Error_Invalid_do_duplicate, Error_Invalid_do_forever, Error_Invalid_expression_by, Error_Invalid_expression_control, Error_Invalid_expression_for, Error_Invalid_expression_general, Error_Invalid_expression_over, Error_Invalid_expression_to, Error_Symbol_expected_LABEL, EXP_BY, EXP_FOR, EXP_TO, RexxInstructionDo::expressions, RexxInstructionDo::forcount, RexxInstructionDo::initial, IS_SUBKEY, RexxToken::isEndOfClause(), RexxToken::isSymbol(), RexxInstructionDo::label, markPosition(), nextReal(), OPERATOR_EQUAL, OPERATOR_STRICT_EQUAL, OREF_NULL, OrefSet, previousToken(), refineSubclass, resetPosition(), SIMPLE_DO, RexxToken::subclass, SUBKEY_BY, SUBKEY_FOR, SUBKEY_FOREVER, SUBKEY_LABEL, SUBKEY_OVER, SUBKEY_TO, SUBKEY_UNTIL, SUBKEY_WHILE, subKeyword(), syntaxError(), TERM_COND, TERM_CONTROL, RexxInstructionDo::to, RexxInstructionDo::type, and RexxToken::value.

◆ createLoop()

RexxInstruction * RexxSource::createLoop ( )

Create a LOOP instruction instance.

Returns

Definition at line 500 of file InstructionParser.cpp.

References new_instruction.

Referenced by loopNew().

◆ createMethod()

void RexxSource::createMethod ( RexxString *  name,
bool  classMethod,
AccessFlag  privateMethod,
ProtectedFlag  protectedMethod,
GuardFlag  guardedMethod,
bool  isAttribute 
)

Create a Rexx method body.

Parameters
nameThe name of the attribute.
classMethodIndicates whether we are creating a class or instance method.
privateMethodThe method's private attribute.
protectedMethodThe method's protected attribute.
guardedMethodThe method's guarded attribute.

Definition at line 3333 of file SourceFile.cpp.

References addMethod(), OREF_NULL, saveObject(), RexxMethod::setAttribute(), 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
nameThe method name.
libraryThe library containing the method.
procedureThe name of the procedure within the package.
Returns
A method object representing this method.

Definition at line 2841 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 1022 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
methodNameThe internal name of the method (uppercased).
externalSpecThe external specification string.
libraryThe returned library name.
procedureThe returned package name.

Definition at line 2865 of file SourceFile.cpp.

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

Referenced by attributeDirective(), and methodDirective().

◆ directive()

void RexxSource::directive ( )

Definition at line 3738 of file SourceFile.cpp.

References attributeDirective(), classDirective(), RexxToken::classId, clause, constantDirective(), DIRECTIVE_ATTRIBUTE, DIRECTIVE_CLASS, DIRECTIVE_CONSTANT, DIRECTIVE_EXTENSION, DIRECTIVE_METHOD, DIRECTIVE_OPTIONS, DIRECTIVE_REQUIRES, DIRECTIVE_ROUTINE, dumpClause, Error_Symbol_expected_directive, Error_Translation_bad_directive, extensionDirective(), flags, IS_DIRECTIVE, RexxToken::isSymbol(), keyDirective(), methodDirective(), nextClause(), nextReal(), no_clause, optionsDirective(), refineSubclass, requiresDirective(), routineDirective(), syntaxError(), and TOKEN_DCOLON.

Referenced by translate().

◆ doNew()

RexxInstruction * RexxSource::doNew ( )

Definition at line 460 of file InstructionParser.cpp.

References createDoLoop().

Referenced by instruction().

◆ dropNew()

RexxInstruction * RexxSource::dropNew ( )

Definition at line 809 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 823 of file InstructionParser.cpp.

References new_instruction.

Referenced by instruction().

◆ endIfNew()

RexxInstruction * RexxSource::endIfNew ( RexxInstructionIf *  parent)

Definition at line 865 of file InstructionParser.cpp.

References new_instruction.

Referenced by flushControl().

◆ endLocation()

void RexxSource::endLocation ( SourceLocation &  location)

Definition at line 211 of file Scanner.cpp.

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

Referenced by nextSpecial(), sourceLiteral(), and sourceNextToken().

◆ endNew()

RexxInstruction * RexxSource::endNew ( )

Definition at line 836 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 6310 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 6300 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 6423 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 6435 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 6448 of file SourceFile.cpp.

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

◆ errorCleanup()

void RexxSource::errorCleanup ( )

Definition at line 6292 of file SourceFile.cpp.

References cleanup().

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

◆ errorLine()

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

Definition at line 6321 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,
SourceLocation  token_location 
)

Definition at line 6334 of file SourceFile.cpp.

References ActivityManager::currentActivity, errorCleanup(), SourceLocation::getLineNumber(), 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 6347 of file SourceFile.cpp.

References RexxToken::classId, clauseLocation, ActivityManager::currentActivity, errorCleanup(), RexxToken::getLocation(), RexxString::getStringData(), SourceLocation::isLimitedTrace(), new_array(), new_string(), OREF_NULL, RexxActivity::raiseException(), SourceLocation::setLimitedTrace(), 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 878 of file InstructionParser.cpp.

References expression(), new_instruction, and TERM_EOC.

Referenced by instruction().

◆ expose()

void RexxSource::expose ( RexxString *  name)

Definition at line 4742 of file SourceFile.cpp.

References exposed_variables, and RexxDirectory::put().

Referenced by processVariableList().

◆ exposeNew()

RexxInstruction * RexxSource::exposeNew ( )

Definition at line 892 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 5196 of file SourceFile.cpp.

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

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

◆ extensionDirective()

void RexxSource::extensionDirective ( )

Process a ::EXTENSION directive for a source file.

Definition at line 2231 of file SourceFile.cpp.

References _install, active_class, active_extension, RexxList::append(), clause, commonString(), Error_Invalid_subkeyword_class, Error_Symbol_or_string_class, Error_Symbol_or_string_inherit, extensions, flags, IS_SUBDIRECTIVE, RexxToken::isEndOfClause(), RexxToken::isSymbol(), RexxToken::isSymbolOrLiteral(), nextReal(), OREF_NULL, OrefSet, previousToken(), refineSubclass, subDirective(), SUBDIRECTIVE_INHERIT, syntaxError(), type, RexxString::upper(), and RexxToken::value.

Referenced by directive().

◆ extract()

RexxString * RexxSource::extract ( SourceLocation &  location,
bool  newline = false 
)

Definition at line 1111 of file SourceFile.cpp.

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

Referenced by addClause(), dumpClauseImpl(), RexxCode::extract(), sourceLiteral(), 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 318 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 1165 of file SourceFile.cpp.

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

◆ extractSource() [2/2]

RexxArray * RexxSource::extractSource ( SourceLocation &  location)

Definition at line 1178 of file SourceFile.cpp.

References RexxString::extract(), get(), SourceLocation::getEndLine(), SourceLocation::getEndOffset(), RexxString::getLength(), SourceLocation::getLineNumber(), SourceLocation::getOffset(), line_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
classNameThe target name of the class.
Returns
The resolved class object, if any.

Definition at line 1727 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(), ExtensionDirective::install(), and RexxActivation::resolveDotVariable().

◆ findInstalledClass()

RexxClass * RexxSource::findInstalledClass ( RexxString *  name)

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

Parameters
nameThe name we're searching for (all uppercase).
Returns
A resolved class object, if found.

Definition at line 1673 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 5025 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
nameThe name we're searching for (all uppercase).
Returns
A resolved class object, if found.

Definition at line 1569 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 1696 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
nameThe target name.
Returns
A resolved Routine object, if found.

Definition at line 1599 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
routineNameThe routine name of interest.
Returns
A RoutineClass instance if located. Returns OREF_NULL if this is not known at this level.

Definition at line 1631 of file SourceFile.cpp.

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

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

◆ firstToken()

void RexxSource::firstToken ( )
inline

Definition at line 316 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 716 of file SourceFile.cpp.

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

◆ flushControl()

void RexxSource::flushControl ( RexxInstruction *  _instruction)

Definition at line 3803 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
settingThe source setting.
Returns
The string representation of the trace setting.

Definition at line 6644 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 1066 of file InstructionParser.cpp.

References new_instruction, and RexxInstructionForwardCreate().

Referenced by instruction().

◆ fullSubExpression()

RexxObject * RexxSource::fullSubExpression ( int  terminators)

Perform the parsing of an expression where the expression can be treated as a comma-separated list of subexpressions. If we have just a simple single subexpression, the return value is the parsed subexpression. If a comma is found as a terminator, then we turn this expression into an operator that will create an array object from the list of expressions. Omitted expressions are allowed and no effort is made to remove trailing null expressions.

Parameters
terminatorsThe list of terminators for this expression type.
Returns
Either a simple expression, or an expression object for creating an array item.

Definition at line 5227 of file SourceFile.cpp.

References RexxToken::isType(), nextToken(), popSubTerm(), previousToken(), pushSubTerm(), subExpression(), subTerms, TERM_COMMA, and TOKEN_COMMA.

Referenced by expression(), and subTerm().

◆ function()

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

Definition at line 5691 of file SourceFile.cpp.

References addReference(), argList(), RexxToken::isLiteral(), removeObj(), saveObject(), TERM_RIGHT, TERM_SQRIGHT, and RexxToken::value.

◆ functionCallMessage()

RexxObject* RexxSource::functionCallMessage ( RexxToken *  ,
RexxObject *  ,
int   
)

Referenced by subTerm().

◆ generateCode()

RexxCode * RexxSource::generateCode ( bool  isMethod)

Definition at line 1305 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 815 of file SourceFile.cpp.

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

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

◆ getDefinedMethods()

RexxDirectory* RexxSource::getDefinedMethods ( )
inline

Definition at line 410 of file SourceFile.hpp.

References install(), and methods.

◆ getDigits()

size_t RexxSource::getDigits ( )
inline

Definition at line 412 of file SourceFile.hpp.

References digits.

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

◆ getEnableCommands()

bool RexxSource::getEnableCommands ( )
inline

Definition at line 418 of file SourceFile.hpp.

References enableCommands.

Referenced by RexxActivation::RexxActivation().

◆ getEnableMacrospace()

bool RexxSource::getEnableMacrospace ( )
inline

Definition at line 419 of file SourceFile.hpp.

References enableMacrospace.

Referenced by RexxActivation::RexxActivation().

◆ getForm()

bool RexxSource::getForm ( )
inline

Definition at line 413 of file SourceFile.hpp.

References form.

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

◆ getFuzz()

size_t RexxSource::getFuzz ( )
inline

Definition at line 414 of file SourceFile.hpp.

References fuzz.

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

◆ getGuard()

RexxArray * RexxSource::getGuard ( )

Definition at line 5055 of file SourceFile.cpp.

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

Referenced by guardNew().

◆ getImportedClasses()

RexxDirectory* RexxSource::getImportedClasses ( )
inline

Definition at line 406 of file SourceFile.hpp.

References install(), and merged_public_classes.

Referenced by PackageClass::getImportedClasses().

◆ getImportedRoutines()

RexxDirectory* RexxSource::getImportedRoutines ( )
inline

Definition at line 409 of file SourceFile.hpp.

References install(), and merged_public_routines.

Referenced by PackageClass::getImportedRoutines().

◆ getInstalledClasses()

RexxDirectory* RexxSource::getInstalledClasses ( )
inline

Definition at line 404 of file SourceFile.hpp.

References install(), and installed_classes.

Referenced by PackageClass::getClasses().

◆ getInstalledPublicClasses()

RexxDirectory* RexxSource::getInstalledPublicClasses ( )
inline

Definition at line 405 of file SourceFile.hpp.

References install(), and installed_public_classes.

Referenced by PackageClass::getPublicClasses().

◆ getInstalledPublicRoutines()

RexxDirectory* RexxSource::getInstalledPublicRoutines ( )
inline

Definition at line 408 of file SourceFile.hpp.

References install(), and public_routines.

Referenced by PackageClass::getPublicRoutines().

◆ getInstalledRoutines()

RexxDirectory* RexxSource::getInstalledRoutines ( )
inline

Definition at line 407 of file SourceFile.hpp.

References install(), and routines.

Referenced by PackageClass::getRoutines().

◆ getIsBlock()

bool RexxSource::getIsBlock ( )
inline

Definition at line 146 of file SourceFile.hpp.

References isBlock.

◆ getLocalRoutines()

RexxDirectory* RexxSource::getLocalRoutines ( )
inline

Definition at line 382 of file SourceFile.hpp.

References routines.

Referenced by RexxCode::getLocalRoutines().

◆ getMethods()

RexxDirectory* RexxSource::getMethods ( )
inline

Definition at line 305 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 6993 of file SourceFile.cpp.

References OREF_NULL, OrefSet, and package.

Referenced by RexxActivity::generateProgramInformation(), RexxActivation::getEffectivePackageObject(), RexxActivation::getPackageObject(), ClassDirective::install(), and RexxActivity::reraiseException().

◆ getPackages()

RexxList* RexxSource::getPackages ( )
inline

Definition at line 411 of file SourceFile.hpp.

References install(), and loadedPackages.

Referenced by PackageClass::getImportedPackages().

◆ getProgramDirectory()

RexxString* RexxSource::getProgramDirectory ( )
inline

Definition at line 302 of file SourceFile.hpp.

References programDirectory.

◆ getProgramExtension()

RexxString* RexxSource::getProgramExtension ( )
inline

Definition at line 303 of file SourceFile.hpp.

References programExtension.

◆ getProgramFile()

RexxString* RexxSource::getProgramFile ( )
inline

Definition at line 304 of file SourceFile.hpp.

References programFile.

◆ getProgramName()

RexxString* RexxSource::getProgramName ( )
inline

Definition at line 301 of file SourceFile.hpp.

References programName.

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

◆ getPublicRoutines()

RexxDirectory* RexxSource::getPublicRoutines ( )
inline

Definition at line 383 of file SourceFile.hpp.

References public_routines.

Referenced by RexxCode::getPublicRoutines().

◆ getRetriever()

RexxVariableBase * RexxSource::getRetriever ( RexxString *  name)

Definition at line 4916 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 306 of file SourceFile.hpp.

References routines.

Referenced by RexxCode::getRoutines().

◆ getSecurityManager()

SecurityManager* RexxSource::getSecurityManager ( )
inline

Definition at line 380 of file SourceFile.hpp.

References securityManager.

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

◆ getToken()

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

Definition at line 5764 of file SourceFile.cpp.

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

Referenced by message().

◆ getTrace()

RexxString* RexxSource::getTrace ( )
inline

Definition at line 417 of file SourceFile.hpp.

References formatTraceSetting(), and traceSetting.

Referenced by PackageClass::trace().

◆ getTraceFlags()

size_t RexxSource::getTraceFlags ( )
inline

Definition at line 416 of file SourceFile.hpp.

References traceFlags.

Referenced by RexxActivation::RexxActivation().

◆ getTraceSetting()

size_t RexxSource::getTraceSetting ( )
inline

Definition at line 415 of file SourceFile.hpp.

References traceSetting.

Referenced by RexxActivation::RexxActivation().

◆ globalSetup()

void RexxSource::globalSetup ( )

Definition at line 1269 of file SourceFile.cpp.

References clause, control, HOLDSIZE, holdstack, literals, namedSubTerms, new_directory(), new_identity_table(), new_list(), new_queue(), operators, OREF_NULL, OrefSet, savelist, sourceLiterals, strings, subTerms, and terms.

Referenced by generateCode(), and interpretMethod().

◆ guardNew()

RexxInstruction * RexxSource::guardNew ( )

Definition at line 1078 of file InstructionParser.cpp.

References Error_Invalid_expression_guard, Error_Invalid_subkeyword_guard, Error_Invalid_subkeyword_guard_on, Error_Symbol_expected_numeric, expression(), getGuard(), IS_SUBKEY, RexxToken::isEndOfClause(), RexxToken::isSymbol(), new_variable_instruction, nextReal(), OREF_NULL, refineSubclass, 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 1395 of file SourceFile.cpp.

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

Referenced by attributeDirective().

◆ holdObject()

void RexxSource::holdObject ( RexxObject *  object)
inline

Definition at line 376 of file SourceFile.hpp.

References holdstack, and RexxStack::push().

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

◆ ifNew()

RexxInstruction * RexxSource::ifNew ( int  type)

Definition at line 1157 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
parentThe parent source context.

Definition at line 1473 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 181 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 275 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 1781 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 295 of file SourceFile.hpp.

References needsInstallation(), and processInstall().

◆ instruction()

RexxInstruction * RexxSource::instruction ( )

Definition at line 4211 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(), IS_KEYWORD, RexxToken::isEndOfClause(), RexxToken::isSymbol(), 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_UPPER, KEYWORD_USE, KEYWORD_WHEN, labelNew(), leaveNew(), loopNew(), markPosition(), 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(), refineSubclass, replyNew(), resetPosition(), returnNew(), saveObject(), sayNew(), selectNew(), signalNew(), RexxToken::subclass, subExpression(), SUBKEY_ARG, SUBKEY_PULL, syntaxError(), TERM_EOC, TOKEN_ASSIGNMENT, TOKEN_COLON, TOKEN_DCOLON, TOKEN_LEFT, TOKEN_LITERAL, TOKEN_SOURCE_LITERAL, TOKEN_SYMBOL, toss(), traceNew(), trimClause(), upperNew(), and useNew().

Referenced by translateBlock().

◆ instructionNew()

RexxInstruction * RexxSource::instructionNew ( int  type)

Definition at line 1189 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,
RexxActivation *  activation 
)

Definition at line 1340 of file SourceFile.cpp.

References ConcurrencyInfos::activation, adjustLine(), interpretMethod(), new_array(), programName, and RexxSource().

Referenced by RexxCode::interpret().

◆ interpretLine()

void RexxSource::interpretLine ( size_t  )

◆ interpretMethod()

RexxCode * RexxSource::interpretMethod ( RexxDirectory *  _labels,
RexxActivation *  _activation 
)

Definition at line 1324 of file SourceFile.cpp.

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

Referenced by interpret().

◆ interpretNew()

RexxInstruction * RexxSource::interpretNew ( )

Definition at line 1201 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 6233 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 329 of file SourceFile.hpp.

References RexxInternalObject::isOldSpace().

Referenced by traceBack().

◆ isInterpret()

bool RexxSource::isInterpret ( )
inline

Definition at line 292 of file SourceFile.hpp.

References _interpret, and flags.

Referenced by RexxCode::isInterpret().

◆ isSymbolCharacter()

static bool RexxSource::isSymbolCharacter ( codepoint_t  ch)
inlinestatic

Definition at line 387 of file SourceFile.hpp.

References characterTable.

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

◆ isTraceable()

bool RexxSource::isTraceable ( )

Definition at line 801 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 560 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 493 of file KeywordConstants.cpp.

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

◆ labelNew()

RexxInstruction * RexxSource::labelNew ( )

Definition at line 1220 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 1240 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 3712 of file SourceFile.cpp.

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

Referenced by requiresDirective().

◆ live()

void RexxSource::live ( size_t  liveMark)
virtual

Reimplemented from RexxVirtualBase.

Definition at line 589 of file SourceFile.cpp.

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

◆ liveGeneral()

void RexxSource::liveGeneral ( int  reason)
virtual

Reimplemented from RexxVirtualBase.

Definition at line 642 of file SourceFile.cpp.

References active_class, active_extension, calls, class_dependencies, classes, clause, control, currentInstruction, exposed_variables, extensions, first, flags, guard_variables, holdstack, initCode, installed_classes, installed_public_classes, interpret_activation, labels, last, libraries, literals, loadedPackages, memory_mark_general, memoryObject, merged_public_classes, merged_public_routines, methods, namedSubTerms, operators, OREF_NULL, OrefSet, package, parentSource, programDirectory, programExtension, programFile, programName, public_routines, reclaim_possible, requires, routines, savelist, RexxMemory::savingImage(), securityManager, sourceArray, sourceBuffer, sourceIndices, sourceLiterals, 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
targetThe name of the ::REQUIRES
instructionThe directive instruction being processed.

Definition at line 6909 of file SourceFile.cpp.

References ConcurrencyInfos::activity, 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
targetThe name of the ::REQUIRES

Definition at line 6938 of file SourceFile.cpp.

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

◆ locateToken()

unsigned int RexxSource::locateToken ( RexxToken *  previous)

Definition at line 291 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_SOURCE_LITERAL, TOKEN_SQRIGHT, and TOKEN_SYMBOL.

Referenced by nextSpecial(), and sourceNextToken().

◆ loopNew()

RexxInstruction * RexxSource::loopNew ( )

Definition at line 470 of file InstructionParser.cpp.

References createDoLoop(), and createLoop().

Referenced by instruction().

◆ markPosition()

size_t RexxSource::markPosition ( )
inline

Definition at line 318 of file SourceFile.hpp.

References clause, and RexxClause::mark().

Referenced by argList(), createDoLoop(), instruction(), and messageTerm().

◆ mergeRequired()

void RexxSource::mergeRequired ( RexxSource *  source)

Definition at line 1483 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 5784 of file SourceFile.cpp.

References addText(), argList(), RexxToken::classId, Error_Invalid_expression_after_tilde, Error_Invalid_expression_message_term, Error_Symbol_expected_colon, getToken(), holdObject(), RexxToken::isSourceLiteral(), RexxToken::isSymbolOrLiteral(), RexxToken::isVariable(), namedSubTerms, 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 1301 of file InstructionParser.cpp.

References RexxExpressionMessage::argumentCount, RexxExpressionMessage::makeAssignment(), RexxExpressionMessage::namedArgumentCount, 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
messageThe target message term.
operationThe operation to perform in the expansion.
expressionThe expression (which is the right-hand term of the eventual expression).
Returns
The constructed message operator.

Definition at line 1330 of file InstructionParser.cpp.

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

Referenced by instruction().

◆ messageNew()

RexxInstruction * RexxSource::messageNew ( RexxExpressionMessage *  _message)

Definition at line 1287 of file InstructionParser.cpp.

References RexxExpressionMessage::argumentCount, RexxExpressionMessage::namedArgumentCount, and new_variable_instruction.

Referenced by instruction().

◆ messageSubterm()

RexxObject * RexxSource::messageSubterm ( int  terminators)

Definition at line 5963 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 5919 of file SourceFile.cpp.

References RexxToken::classId, collectionMessage(), holdObject(), markPosition(), message(), nextToken(), OREF_NULL, previousToken(), resetPosition(), subTerm(), TERM_COMMA, 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 2386 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, IS_SUBDIRECTIVE, RexxToken::isEndOfClause(), RexxToken::isLiteral(), RexxToken::isSymbol(), RexxToken::isSymbolOrLiteral(), nextReal(), OREF_NULL, PACKAGE_SCOPE, PRIVATE_SCOPE, PROTECTED_METHOD, PUBLIC_SCOPE, refineSubclass, saveObject(), RexxMethod::setAbstract(), RexxMethod::setAttribute(), RexxMethod::setAttributes(), BaseExecutable::setSourceObject(), subDirective(), SUBDIRECTIVE_ABSTRACT, SUBDIRECTIVE_ATTRIBUTE, SUBDIRECTIVE_CLASS, SUBDIRECTIVE_EXTERNAL, SUBDIRECTIVE_GUARDED, SUBDIRECTIVE_PACKAGE, 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 294 of file SourceFile.hpp.

References _install, and flags.

Referenced by install().

◆ needVariable()

void RexxSource::needVariable ( RexxToken *  token)

Definition at line 382 of file SourceFile.cpp.

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

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

◆ needVariableOrDotSymbol()

void RexxSource::needVariableOrDotSymbol ( RexxToken *  token)

Definition at line 403 of file SourceFile.cpp.

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

◆ nextClause()

void RexxSource::nextClause ( )

Definition at line 936 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 504 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

Definition at line 314 of file SourceFile.hpp.

References clause, and RexxClause::nextRealToken().

Referenced by addressNew(), argList(), attributeDirective(), callNew(), checkDirective(), classDirective(), constantDirective(), constantExpression(), constantLogicalExpression(), createDoLoop(), directive(), endNew(), expression(), extensionDirective(), guardNew(), hasBody(), ifNew(), instruction(), labelNew(), leaveNew(), libraryDirective(), methodDirective(), nopNew(), numericNew(), optionsDirective(), parseConditional(), parseNew(), procedureNew(), processVariableList(), raiseNew(), requiresDirective(), RexxInstructionForwardCreate(), routineDirective(), selectNew(), signalNew(), subExpression(), traceNew(), translateBlock(), useNew(), and variableOrMessageTerm().

◆ nextSpecial()

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

Definition at line 221 of file Scanner.cpp.

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

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

◆ nextToken()

RexxToken* RexxSource::nextToken ( )
inline

Definition at line 313 of file SourceFile.hpp.

References clause, and RexxClause::next().

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

◆ nopNew()

RexxInstruction * RexxSource::nopNew ( )

Definition at line 1352 of file InstructionParser.cpp.

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

Referenced by instruction().

◆ numericNew()

RexxInstruction * RexxSource::numericNew ( )

Definition at line 1370 of file InstructionParser.cpp.

References Error_Invalid_data_form, Error_Invalid_expression_form, Error_Invalid_subkeyword_form, Error_Invalid_subkeyword_numeric, Error_Symbol_expected_numeric, expression(), IS_SUBKEY, RexxToken::isEndOfClause(), RexxToken::isSymbol(), new_instruction, nextReal(), numeric_engineering, numeric_form_default, numeric_propagate, OREF_NULL, previousToken(), refineSubclass, SUBKEY_DIGITS, SUBKEY_ENGINEERING, SUBKEY_FORM, SUBKEY_FUZZ, SUBKEY_PROPAGATE, SUBKEY_SCIENTIFIC, SUBKEY_VALUE, subKeyword(), syntaxError(), TERM_EOC, and type.

Referenced by instruction().

◆ operator delete() [1/2]

void RexxSource::operator delete ( void *  )
inline

Definition at line 138 of file SourceFile.hpp.

◆ operator delete() [2/2]

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

Definition at line 139 of file SourceFile.hpp.

◆ operator new() [1/2]

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

Definition at line 137 of file SourceFile.hpp.

◆ operator new() [2/2]

void * RexxSource::operator new ( size_t  size)

Definition at line 6502 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 2668 of file SourceFile.cpp.

References digits, enableCommands, enableMacrospace, 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, IS_SUBDIRECTIVE, IS_SUBKEY, RexxToken::isEndOfClause(), RexxToken::isSymbol(), RexxToken::isSymbolOrLiteral(), new_string(), nextReal(), number_digits(), parseTraceSetting(), refineSubclass, reportException(), RexxObject::requestUnsignedNumber(), subDirective(), SUBDIRECTIVE_COMMANDS, SUBDIRECTIVE_DIGITS, SUBDIRECTIVE_FORM, SUBDIRECTIVE_FUZZ, SUBDIRECTIVE_MACROSPACE, SUBDIRECTIVE_NOCOMMANDS, SUBDIRECTIVE_NOMACROSPACE, SUBDIRECTIVE_TRACE, SUBKEY_ENGINEERING, SUBKEY_SCIENTIFIC, subKeyword(), syntaxError(), traceFlags, traceSetting, and RexxToken::value.

Referenced by directive().

◆ optionsNew()

RexxInstruction * RexxSource::optionsNew ( )

Definition at line 1494 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 1511 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 429 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, RexxObject::messageSend(), new_integer(), new_string(), RexxString::putChar(), raw_string(), syntaxError(), and type.

Referenced by sourceNextToken().

◆ parenExpression()

RexxObject * RexxSource::parenExpression ( RexxToken *  start)

Definition at line 5175 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 6786 of file SourceFile.cpp.

References Error_Invalid_do_whileuntil, Error_Invalid_expression_until, Error_Invalid_expression_while, IS_SUBKEY, RexxToken::isEndOfClause(), RexxToken::isSymbol(), nextReal(), nextToken(), OREF_NULL, parseLogical(), refineSubclass, 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
terminatorsThe 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 6877 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 1524 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(), IS_SUBKEY, 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(), refineSubclass, 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, 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 546 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
valueThe string source of the trace setting.
newSettingThe returned setting in binary form.
debugFlagsThe debug flag representation of the trace setting.

Definition at line 6538 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 298 of file SourceFile.hpp.

References control, and RexxQueue::pullRexx().

Referenced by flushControl(), and translateBlock().

◆ popNTerms()

RexxObject * RexxSource::popNTerms ( size_t  count)

Definition at line 6216 of file SourceFile.cpp.

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

Referenced by argList().

◆ popOperator()

RexxToken* RexxSource::popOperator ( )
inline

Definition at line 308 of file SourceFile.hpp.

References operators, and RexxQueue::pullRexx().

Referenced by subExpression().

◆ popSubTerm()

RexxObject * RexxSource::popSubTerm ( )

Pop a term off of the expression sub term stack.

Returns
The popped object.

Definition at line 6204 of file SourceFile.cpp.

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

Referenced by fullSubExpression().

◆ popTerm()

RexxObject * RexxSource::popTerm ( )

Definition at line 6164 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 
)

Definition at line 518 of file SourceFile.cpp.

References current, current_length, Error_Translation_invalid_line, RexxArray::get(), RexxBuffer::getData(), RexxString::getLength(), RexxString::getStringData(), isOfClass, _LINE_DESCRIPTOR::length, line, line_adjust, line_count, line_number, line_offset, OREF_NULL, _LINE_DESCRIPTOR::position, reportException(), sourceArray, sourceBuffer, sourceIndices, RexxString::stringValue(), and TheNilObject.

Referenced by argList(), get(), RexxActivation::getMethodArgument(), RexxActivation::getProgramArgument(), initBuffered(), locateToken(), nextLine(), and RexxSource().

◆ precedence()

int RexxSource::precedence ( RexxToken *  token)
static

Definition at line 53 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, RexxToken::precedence, and RexxToken::subclass.

Referenced by subExpression().

◆ previousToken()

void RexxSource::previousToken ( )
inline

Definition at line 315 of file SourceFile.hpp.

References clause, and RexxClause::previous().

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

◆ procedureNew()

RexxInstruction * RexxSource::procedureNew ( )

Definition at line 1830 of file InstructionParser.cpp.

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

Referenced by instruction().

◆ processInstall()

void RexxSource::processInstall ( RexxActivation *  activation)

Definition at line 1797 of file SourceFile.cpp.

References _install, ConcurrencyInfos::activation, classes, extensions, RexxList::firstIndex(), flags, RexxArray::get(), RexxList::getValue(), LibraryDirective::install(), RequiresDirective::install(), ClassDirective::install(), ExtensionDirective::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)

Definition at line 6666 of file SourceFile.cpp.

References addText(), RexxToken::classId, currentstack, Error_Invalid_variable_number, Error_Invalid_variable_period, Error_Symbol_expected_drop, Error_Symbol_expected_expose, Error_Symbol_expected_upper, Error_Symbol_expected_varref, Error_Variable_reference_extra, Error_Variable_reference_missing, expose(), RexxToken::isEndOfClause(), RexxToken::isSymbol(), KEYWORD_DROP, KEYWORD_EXPOSE, KEYWORD_UPPER, nextReal(), RexxQueue::push(), RexxQueue::queue(), RexxToken::subclass, subTerms, SYMBOL_CONSTANT, SYMBOL_DUMMY, syntaxError(), TOKEN_LEFT, TOKEN_RIGHT, type, and RexxToken::value.

Referenced by dropNew(), exposeNew(), procedureNew(), and upperNew().

◆ pushDo()

void RexxSource::pushDo ( RexxInstruction *  i)
inline

Definition at line 297 of file SourceFile.hpp.

References control, and RexxQueue::pushRexx().

Referenced by flushControl(), and translateBlock().

◆ pushOperator()

void RexxSource::pushOperator ( RexxToken *  operatorToken)
inline

Definition at line 307 of file SourceFile.hpp.

References operators, and RexxQueue::pushRexx().

Referenced by subExpression().

◆ pushSubTerm()

void RexxSource::pushSubTerm ( RexxObject *  term)

Push a term on to the expression sub term stack. The subterms normally contribute to the total required stack size, so make sure we account for these when calculating the total required stack size. Only use this method of pushing the term when the max stack size is affected.

Parameters
termThe term object.

Definition at line 6186 of file SourceFile.cpp.

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

Referenced by fullSubExpression().

◆ pushTerm()

void RexxSource::pushTerm ( RexxObject *  term)

Definition at line 6148 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 1860 of file InstructionParser.cpp.

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

Referenced by instruction().

◆ raiseNew()

RexxInstruction * RexxSource::raiseNew ( )

Definition at line 1874 of file InstructionParser.cpp.

References argList(), 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, IS_CONDITION, IS_SUBKEY, RexxToken::isEndOfClause(), RexxToken::isSymbol(), new_instruction, new_queue(), new_variable_instruction, nextReal(), nextToken(), OREF_NULL, RexxQueue::push(), RexxQueue::queue(), refineSubclass, saveObject(), SIZE_MAX, 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 310 of file SourceFile.hpp.

References flags, and reclaimed.

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

◆ reconnect()

bool RexxSource::reconnect ( )

Definition at line 344 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 378 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 2069 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 3686 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 319 of file SourceFile.hpp.

References clause, and RexxClause::reset().

Referenced by argList(), createDoLoop(), instruction(), and messageTerm().

◆ resolveBuiltin()

size_t RexxSource::resolveBuiltin ( RexxString *  value)
static

Definition at line 522 of file KeywordConstants.cpp.

References builtinFunctions, resolveKeyword(), and tabSize.

Referenced by RexxInstructionCall::execute().

◆ resolveDependencies()

void RexxSource::resolveDependencies ( )

Definition at line 1944 of file SourceFile.cpp.

References ClassDirective::addDependencies(), RexxList::append(), class_dependencies, classes, clauseLocation, ClassDirective::dependenciesResolved(), Error_Execution_cyclic, RexxList::firstIndex(), RexxInstruction::getLocation(), ClassDirective::getName(), RexxList::getValue(), RexxDirectory::items(), RexxList::items(), libraries, LIST_END, methods, new_list(), RexxList::nextIndex(), OREF_NULL, OrefSet, programName, public_routines, ClassDirective::removeDependency(), RexxList::removeIndex(), requires, routines, and syntaxError().

Referenced by translate().

◆ resolveKeyword()

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

Resolve a token to a potential subkeyword.

Parameters
tokenThe token to resolve.
TableThe table to search.
Table_SizeThe size of the table.
Returns
The numeric identifier for the constant. Returns 0 if not found in the target table.

Definition at line 419 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
activityThe current activity
nameThe target name
Returns
The fully resolved string name of the target program, if one is located.

Definition at line 1659 of file SourceFile.cpp.

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

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

◆ returnNew()

RexxInstruction * RexxSource::returnNew ( )

Definition at line 2082 of file InstructionParser.cpp.

References expression(), new_instruction, and TERM_EOC.

Referenced by instruction().

◆ RexxInstructionForwardCreate()

void RexxSource::RexxInstructionForwardCreate ( RexxInstructionForward *  newObject)

Definition at line 907 of file InstructionParser.cpp.

References argArray(), 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_expression_user_defined, 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, IS_SUBKEY, RexxToken::isEndOfClause(), RexxToken::isSymbol(), RexxInstructionForward::message, RexxInstructionForward::namedArgumentsArray, RexxInstructionForward::namedArgumentsExpression, new_string(), nextReal(), OREF_NULL, OrefSet, refineSubclass, SUBKEY_ARGUMENTS, SUBKEY_ARRAY, SUBKEY_CLASS, SUBKEY_CONTINUE, SUBKEY_MESSAGE, SUBKEY_NAMEDARGUMENTS, 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 3477 of file SourceFile.cpp.

References _install, 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(), IS_SUBDIRECTIVE, RexxToken::isEndOfClause(), RexxToken::isLiteral(), RexxToken::isSymbol(), RexxToken::isSymbolOrLiteral(), nextReal(), OREF_NULL, PRIVATE_SCOPE, public_routines, PUBLIC_SCOPE, refineSubclass, 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 377 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 2096 of file InstructionParser.cpp.

References expression(), new_instruction, and TERM_EOC.

Referenced by instruction().

◆ selectNew()

RexxInstruction * RexxSource::selectNew ( )

Definition at line 2109 of file InstructionParser.cpp.

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

Referenced by instruction().

◆ setBufferedSource()

void RexxSource::setBufferedSource ( RexxBuffer *  newSource)
inline

Definition at line 152 of file SourceFile.hpp.

References initBuffered().

Referenced by RoutineClass::processInstore().

◆ setGuard()

void RexxSource::setGuard ( )

Definition at line 5042 of file SourceFile.cpp.

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

Referenced by guardNew().

◆ setIsBlock()

void RexxSource::setIsBlock ( bool  b)
inline

Definition at line 145 of file SourceFile.hpp.

References isBlock.

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

◆ setLocalRoutines()

void RexxSource::setLocalRoutines ( RexxDirectory *  r)
inline

Definition at line 384 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
nameThe new program name.

Definition at line 338 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 385 of file SourceFile.hpp.

References public_routines.

Referenced by RexxCode::setPublicRoutines().

◆ setReconnect()

void RexxSource::setReconnect ( )

Definition at line 357 of file SourceFile.cpp.

References flags, and reclaim_possible.

◆ setSecurityManager()

void RexxSource::setSecurityManager ( RexxObject *  manager)
inline

Definition at line 379 of file SourceFile.hpp.

References OrefSet, and securityManager.

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

◆ signalNew()

RexxInstruction * RexxSource::signalNew ( )

Definition at line 2161 of file InstructionParser.cpp.

References addReference(), 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(), IS_CONDITION, IS_SUBKEY, RexxToken::isEndOfClause(), RexxToken::isSymbol(), RexxToken::isSymbolOrLiteral(), new_instruction, nextReal(), OREF_NULL, previousToken(), refineSubclass, signal_on, SUBKEY_NAME, SUBKEY_OFF, SUBKEY_ON, SUBKEY_VALUE, subKeyword(), syntaxError(), TERM_EOC, and RexxToken::value.

Referenced by instruction().

◆ sourceLiteral()

RexxToken * RexxSource::sourceLiteral ( size_t  clause_free,
SourceLocation  location 
)

Definition at line 653 of file Scanner.cpp.

References clause, clauseLocation, commonString(), endLocation(), Error_Unmatched_parenthesis_curly, extract(), RexxClause::free, RexxClause::getLocation(), line_number, line_offset, RexxClause::newToken(), nextSpecial(), OREF_NULL, RexxClause::setEnd(), SourceLocation::setLimitedTrace(), sourceNextToken(), syntaxErrorAt(), and TOKEN_SOURCE_LITERAL.

Referenced by sourceNextToken().

◆ sourceNewObject()

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

Definition at line 6512 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 688 of file Scanner.cpp.

References AFTER_INTEGER, AFTER_NUMBER, RexxClause::cachedToken, 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_Unexpected_curly_bracket, Error_Unmatched_quote_double, Error_Unmatched_quote_single, EXP_DIGIT, EXP_E, EXP_EDIGIT, EXP_ESIGN, EXP_EXCLUDED, EXP_POINT, EXP_SPOINT, EXP_START, RexxClause::free, GETCHAR, RexxString::getChar(), RexxClause::getLocation(), HIGHEST_PRECEDENCE, INTEGER_CONSTANT, isSymbolCharacter(), line_number, line_offset, LITERAL_BIN, LITERAL_HEX, locateToken(), MAX_SYMBOL_LENGTH, MORELINE, new_string(), RexxClause::newToken(), nextLine(), nextSpecial(), OPERATOR, OPERATOR_ABUTTAL, OPERATOR_BLANK, OREF_NULL, packLiteral(), RexxToken::precedence, RexxString::putChar(), raw_string(), RexxClause::setEnd(), SourceLocation::setEndOffset(), SourceLocation::setLocation(), RexxToken::setNumeric(), RexxString::setUpperOnly(), sourceLiteral(), startLocation(), 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_OPERATOR, TOKEN_RIGHT, TOKEN_SQLEFT, TOKEN_SQRIGHT, TOKEN_SYMBOL, TOKEN_TILDE, translateChar(), and type.

Referenced by nextClause(), and sourceLiteral().

◆ sourceSize()

size_t RexxSource::sourceSize ( )

Definition at line 783 of file SourceFile.cpp.

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

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

◆ startLocation()

void RexxSource::startLocation ( SourceLocation &  location)

Definition at line 201 of file Scanner.cpp.

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

Referenced by sourceNextToken().

◆ subDirective()

int RexxSource::subDirective ( RexxToken *  token)
static

Definition at line 574 of file KeywordConstants.cpp.

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

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

◆ subExpression()

RexxObject * RexxSource::subExpression ( int  terminators)

Definition at line 5272 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(), fullSubExpression(), instruction(), and parenExpression().

◆ subKeyword()

int RexxSource::subKeyword ( RexxToken *  token)
static

Definition at line 479 of file KeywordConstants.cpp.

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

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

◆ subTerm()

RexxObject * RexxSource::subTerm ( int  terminators)

Definition at line 6035 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, fullSubExpression(), functionCallMessage(), RexxToken::isSourceLiteral(), nextToken(), OPERATOR_BACKSLASH, OPERATOR_PLUS, OPERATOR_SUBTRACT, OREF_NULL, previousToken(), RexxToken::subclass, syntaxError(), syntaxErrorAt(), TERM_RIGHT, terminator(), TOKEN_COMMA, TOKEN_LEFT, TOKEN_LITERAL, TOKEN_OPERATOR, TOKEN_RIGHT, TOKEN_SOURCE_LITERAL, TOKEN_SQRIGHT, and TOKEN_SYMBOL.

Referenced by messageSubterm(), and messageTerm().

◆ syntaxError() [1/6]

void RexxSource::syntaxError ( int  errorcode)
inline

Definition at line 328 of file SourceFile.hpp.

References error().

◆ syntaxError() [2/6]

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

Definition at line 320 of file SourceFile.hpp.

References errorLine().

Referenced by addressNew(), argList(), assignmentNew(), assignmentOpNew(), attributeDirective(), blockError(), callNew(), checkDirective(), checkDuplicateMethod(), classDirective(), comment(), constantDirective(), constantExpression(), constantLogicalExpression(), createDoLoop(), createNativeMethod(), decodeExternalMethod(), directive(), endNew(), extensionDirective(), 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 324 of file SourceFile.hpp.

References error().

◆ syntaxError() [4/6]

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

Definition at line 325 of file SourceFile.hpp.

References error().

◆ syntaxError() [5/6]

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

Definition at line 326 of file SourceFile.hpp.

References error().

◆ syntaxError() [6/6]

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

Definition at line 327 of file SourceFile.hpp.

References errorToken().

◆ syntaxErrorAt() [1/2]

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

Definition at line 322 of file SourceFile.hpp.

References errorPosition(), and RexxToken::getLocation().

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

◆ syntaxErrorAt() [2/2]

void RexxSource::syntaxErrorAt ( int  errorcode,
SourceLocation  token_location 
)
inline

Definition at line 323 of file SourceFile.hpp.

References errorPosition().

◆ terminator() [1/2]

bool RexxSource::terminator ( int  ,
RexxObject *   
)

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

◆ terminator() [2/2]

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

Definition at line 415 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 2366 of file InstructionParser.cpp.

References new_instruction.

Referenced by translateBlock().

◆ topDo()

RexxInstruction* RexxSource::topDo ( )
inline

Definition at line 299 of file SourceFile.hpp.

References control, and RexxQueue::peek().

Referenced by flushControl(), and translateBlock().

◆ topOperator()

RexxToken* RexxSource::topOperator ( )
inline

Definition at line 309 of file SourceFile.hpp.

References operators, and RexxQueue::peek().

Referenced by subExpression().

◆ toss()

RexxObject * RexxSource::toss ( RexxObject *  object)

Definition at line 1417 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
activationThe activation of the current running code. This can be null if this is a translation time error.
locationThe source line location.
indentThe indentation amount to apply to the trace line
traceThis is a traced line vs. an error line
Returns
A formatted trace line, including headers and indentations.

Definition at line 1045 of file SourceFile.cpp.

References ConcurrencyInfos::activation, 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 ( )

Definition at line 2380 of file InstructionParser.cpp.

References DEBUG_NOTRACE, Error_Invalid_data_trace, Error_Invalid_expression_general, Error_Invalid_expression_trace, Error_Invalid_trace_trace, Error_Invalid_whole_number_trace, expression(), IS_SUBKEY, RexxToken::isEndOfClause(), RexxToken::isLiteral(), RexxToken::isSymbol(), new_instruction, new_string(), nextReal(), number_digits(), OPERATOR_PLUS, OPERATOR_SUBTRACT, OREF_NULL, parseTraceSetting(), previousToken(), refineSubclass, RexxObject::requestNumber(), RexxToken::subclass, SUBKEY_VALUE, subKeyword(), syntaxError(), TERM_EOC, TRACE_NORMAL, and RexxToken::value.

Referenced by instruction().

◆ translate()

RexxCode * RexxSource::translate ( RexxDirectory *  _labels)

Definition at line 1883 of file SourceFile.cpp.

References _interpret, active_class, active_extension, atEnd(), class_dependencies, classes, clause, ActivityManager::currentActivity, Numerics::DEFAULT_DIGITS, RexxActivation::default_enable_commands, RexxActivation::default_enable_macrospace, Numerics::DEFAULT_FORM, Numerics::DEFAULT_FUZZ, RexxActivation::default_trace_flags, DEFAULT_TRACE_SETTING, digits, directive(), dumpClause, dumpTokens, enableCommands, enableMacrospace, Error_Translation_directive_interpret, extensions, 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 3866 of file SourceFile.cpp.

References _interpret, addClause(), blockSyntaxError(), calls, clause, currentstack, dumpClause, dumpTokens, 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_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 ( codepoint_t  ch)
inlinestatic

Definition at line 394 of file SourceFile.hpp.

References characterTable.

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

◆ trimClause()

void RexxSource::trimClause ( )
inline

Definition at line 317 of file SourceFile.hpp.

References clause, and RexxClause::trim().

Referenced by instruction(), and translateBlock().

◆ upperNew()

RexxInstruction * RexxSource::upperNew ( )

Definition at line 2501 of file InstructionParser.cpp.

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

Referenced by instruction().

◆ useNew()

RexxInstruction * RexxSource::useNew ( )

Parse a USE STRICT ARG instruction.

Returns
The executable instruction object.

Definition at line 2520 of file InstructionParser.cpp.

References RexxToken::classId, constantExpression(), Error_Invalid_expression_use_arg_default, Error_Invalid_subkeyword_use, Error_Skipped_variable_not_allowed_USE_NAMED, Error_Translation_use_strict_ellipsis, Error_Variable_expected_USE, Error_Variable_reference_use, Error_Variable_symbol_expected_USE_NAMED, RexxString::getLength(), RexxVariableBase::getName(), IS_SUBKEY, RexxVariableBase::isAllowedForUseNamed(), RexxToken::isEndOfClause(), RexxToken::isSymbol(), new_queue(), new_variable_instruction, nextReal(), OPERATOR_EQUAL, OREF_NULL, previousToken(), RexxQueue::push(), refineSubclass, removeObj(), saveObject(), RexxString::strCompare(), RexxToken::subclass, SUBKEY_ARG, SUBKEY_AUTO, SUBKEY_NAMED, 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 5890 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 6255 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 134 of file SourceFile.hpp.

Member Data Documentation

◆ active_class

ClassDirective* RexxSource::active_class
protected

Definition at line 518 of file SourceFile.hpp.

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

◆ active_extension

ExtensionDirective* RexxSource::active_extension
protected

Definition at line 519 of file SourceFile.hpp.

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

◆ builtinFunctions

KeywordEntry RexxSource::builtinFunctions
staticprotected

Definition at line 541 of file SourceFile.hpp.

Referenced by builtin(), and resolveBuiltin().

◆ builtinTable

pbuiltin RexxSource::builtinTable
static

Definition at line 421 of file SourceFile.hpp.

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

◆ calls

RexxList* RexxSource::calls
protected

Definition at line 530 of file SourceFile.hpp.

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

◆ characterTable

int RexxSource::characterTable
staticprotected

Definition at line 547 of file SourceFile.hpp.

Referenced by isSymbolCharacter(), and translateChar().

◆ class_dependencies

RexxDirectory* RexxSource::class_dependencies
protected

Definition at line 517 of file SourceFile.hpp.

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

◆ classes

RexxList* RexxSource::classes
protected

Definition at line 483 of file SourceFile.hpp.

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

◆ clause

RexxClause* RexxSource::clause
protected

Definition at line 462 of file SourceFile.hpp.

Referenced by checkDirective(), classDirective(), cleanup(), comment(), directive(), extensionDirective(), firstToken(), globalSetup(), hasBody(), libraryDirective(), live(), liveGeneral(), markPosition(), nextClause(), nextLine(), nextReal(), nextToken(), packLiteral(), previousToken(), requiresDirective(), resetPosition(), sourceLiteral(), sourceNewObject(), sourceNextToken(), translate(), translateBlock(), and trimClause().

◆ clauseLocation

SourceLocation RexxSource::clauseLocation
protected

Definition at line 463 of file SourceFile.hpp.

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

◆ conditionKeywords

KeywordEntry RexxSource::conditionKeywords
staticprotected
Initial value:
= {
KeywordEntry(CHAR_ANY, CONDITION_ANY),
KeywordEntry(CHAR_ERROR, CONDITION_ERROR),
KeywordEntry(CHAR_FAILURE, CONDITION_FAILURE),
KeywordEntry(CHAR_HALT, CONDITION_HALT),
KeywordEntry(CHAR_LOSTDIGITS, CONDITION_LOSTDIGITS),
KeywordEntry(CHAR_NOMETHOD, CONDITION_NOMETHOD),
KeywordEntry(CHAR_NOSTRING, CONDITION_NOSTRING),
KeywordEntry(CHAR_NOTREADY, CONDITION_NOTREADY),
KeywordEntry(CHAR_NOVALUE, CONDITION_NOVALUE),
KeywordEntry(CHAR_PROPAGATE, CONDITION_PROPAGATE),
KeywordEntry(CHAR_SYNTAX, CONDITION_SYNTAX),
KeywordEntry(CHAR_USER, CONDITION_USER),
}
CONDITION_NOSTRING
#define CONDITION_NOSTRING
Definition: Token.hpp:310
CONDITION_LOSTDIGITS
#define CONDITION_LOSTDIGITS
Definition: Token.hpp:316
CONDITION_SYNTAX
#define CONDITION_SYNTAX
Definition: Token.hpp:314
CONDITION_USER
#define CONDITION_USER
Definition: Token.hpp:315
CONDITION_ANY
#define CONDITION_ANY
Definition: Token.hpp:305
CONDITION_PROPAGATE
#define CONDITION_PROPAGATE
Definition: Token.hpp:313
CONDITION_NOMETHOD
#define CONDITION_NOMETHOD
Definition: Token.hpp:309
CONDITION_NOVALUE
#define CONDITION_NOVALUE
Definition: Token.hpp:312
CONDITION_ERROR
#define CONDITION_ERROR
Definition: Token.hpp:306
CONDITION_FAILURE
#define CONDITION_FAILURE
Definition: Token.hpp:307
CONDITION_NOTREADY
#define CONDITION_NOTREADY
Definition: Token.hpp:311
CONDITION_HALT
#define CONDITION_HALT
Definition: Token.hpp:308
KeywordEntry
Definition: SourceFile.hpp:119

Definition at line 542 of file SourceFile.hpp.

Referenced by condition().

◆ control

RexxQueue* RexxSource::control
protected

Definition at line 512 of file SourceFile.hpp.

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

◆ current

const char* RexxSource::current
protected

Definition at line 461 of file SourceFile.hpp.

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

◆ current_length

size_t RexxSource::current_length
protected

Definition at line 466 of file SourceFile.hpp.

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

◆ currentInstruction

RexxInstruction* RexxSource::currentInstruction
protected

Definition at line 525 of file SourceFile.hpp.

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

◆ currentstack

size_t RexxSource::currentstack
protected

Definition at line 531 of file SourceFile.hpp.

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

◆ DEBUG_IGNORE

const size_t RexxSource::DEBUG_IGNORE = 0x0000
static

Definition at line 443 of file SourceFile.hpp.

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

◆ DEBUG_NOTRACE

const size_t RexxSource::DEBUG_NOTRACE = 0x0800
static

Definition at line 447 of file SourceFile.hpp.

Referenced by traceNew().

◆ DEBUG_OFF

const size_t RexxSource::DEBUG_OFF = 0x0200
static

Definition at line 445 of file SourceFile.hpp.

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

◆ DEBUG_ON

const size_t RexxSource::DEBUG_ON = 0x0100
static

Definition at line 444 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 446 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 434 of file SourceFile.hpp.

Referenced by translate().

◆ digits

size_t RexxSource::digits
protected

Definition at line 493 of file SourceFile.hpp.

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

◆ directives

KeywordEntry RexxSource::directives
staticprotected
Initial value:
= {
KeywordEntry(CHAR_ATTRIBUTE, DIRECTIVE_ATTRIBUTE),
KeywordEntry(CHAR_CLASS, DIRECTIVE_CLASS),
KeywordEntry(CHAR_CONSTANT, DIRECTIVE_CONSTANT),
KeywordEntry(CHAR_EXTENSION, DIRECTIVE_EXTENSION),
KeywordEntry(CHAR_METHOD, DIRECTIVE_METHOD),
KeywordEntry(CHAR_OPTIONS, DIRECTIVE_OPTIONS),
KeywordEntry(CHAR_REQUIRES, DIRECTIVE_REQUIRES),
KeywordEntry(CHAR_ROUTINE, DIRECTIVE_ROUTINE),
}
DIRECTIVE_CLASS
#define DIRECTIVE_CLASS
Definition: Token.hpp:266
DIRECTIVE_METHOD
#define DIRECTIVE_METHOD
Definition: Token.hpp:267
DIRECTIVE_EXTENSION
#define DIRECTIVE_EXTENSION
Definition: Token.hpp:272
DIRECTIVE_REQUIRES
#define DIRECTIVE_REQUIRES
Definition: Token.hpp:265
DIRECTIVE_ROUTINE
#define DIRECTIVE_ROUTINE
Definition: Token.hpp:268
DIRECTIVE_ATTRIBUTE
#define DIRECTIVE_ATTRIBUTE
Definition: Token.hpp:269
DIRECTIVE_OPTIONS
#define DIRECTIVE_OPTIONS
Definition: Token.hpp:271
DIRECTIVE_CONSTANT
#define DIRECTIVE_CONSTANT
Definition: Token.hpp:270

Definition at line 538 of file SourceFile.hpp.

Referenced by keyDirective().

◆ enableCommands

bool RexxSource::enableCommands
protected

Definition at line 498 of file SourceFile.hpp.

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

◆ enableMacrospace

bool RexxSource::enableMacrospace
protected

Definition at line 499 of file SourceFile.hpp.

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

◆ exposed_variables

RexxDirectory* RexxSource::exposed_variables
protected

Definition at line 529 of file SourceFile.hpp.

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

◆ extensions

RexxList* RexxSource::extensions
protected

Definition at line 484 of file SourceFile.hpp.

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

◆ first

RexxInstruction* RexxSource::first
protected

Definition at line 523 of file SourceFile.hpp.

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

◆ flags

size_t RexxSource::flags
protected

Definition at line 454 of file SourceFile.hpp.

Referenced by addStem(), addVariable(), atEnd(), callNew(), checkDirective(), classDirective(), directive(), extensionDirective(), 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 495 of file SourceFile.hpp.

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

◆ fuzz

size_t RexxSource::fuzz
protected

Definition at line 494 of file SourceFile.hpp.

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

◆ guard_variables

RexxIdentityTable* RexxSource::guard_variables
protected

Definition at line 528 of file SourceFile.hpp.

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

◆ holdstack

RexxStack* RexxSource::holdstack
protected

Definition at line 508 of file SourceFile.hpp.

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

◆ initCode

RexxCode* RexxSource::initCode
protected

Definition at line 473 of file SourceFile.hpp.

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

◆ installed_classes

RexxDirectory* RexxSource::installed_classes
protected

Definition at line 487 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 486 of file SourceFile.hpp.

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

◆ interpret_activation

RexxActivation* RexxSource::interpret_activation
protected

Definition at line 471 of file SourceFile.hpp.

Referenced by flatten(), interpretMethod(), live(), and liveGeneral().

◆ isBlock

bool RexxSource::isBlock
protected

Definition at line 478 of file SourceFile.hpp.

Referenced by getIsBlock(), RexxActivation::RexxActivation(), and setIsBlock().

◆ keywordInstructions

KeywordEntry RexxSource::keywordInstructions
staticprotected

Definition at line 539 of file SourceFile.hpp.

Referenced by keyword().

◆ labels

RexxDirectory* RexxSource::labels
protected

Definition at line 527 of file SourceFile.hpp.

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

◆ last

RexxInstruction* RexxSource::last
protected

Definition at line 524 of file SourceFile.hpp.

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

◆ libraries

RexxList* RexxSource::libraries
protected

Definition at line 481 of file SourceFile.hpp.

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

◆ line_adjust

size_t RexxSource::line_adjust
protected

Definition at line 470 of file SourceFile.hpp.

Referenced by adjustLine(), extractSource(), and position().

◆ line_count

size_t RexxSource::line_count
protected

Definition at line 467 of file SourceFile.hpp.

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

◆ line_number

size_t RexxSource::line_number
protected

Definition at line 468 of file SourceFile.hpp.

Referenced by adjustLine(), atEnd(), comment(), endLocation(), locateToken(), nextClause(), nextLine(), position(), sourceLiteral(), sourceNextToken(), and startLocation().

◆ line_offset

size_t RexxSource::line_offset
protected

Definition at line 469 of file SourceFile.hpp.

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

◆ literals

RexxDirectory* RexxSource::literals
protected

Definition at line 509 of file SourceFile.hpp.

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

◆ loadedPackages

RexxList* RexxSource::loadedPackages
protected

Definition at line 475 of file SourceFile.hpp.

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

◆ maxstack

size_t RexxSource::maxstack
protected

Definition at line 532 of file SourceFile.hpp.

Referenced by pushSubTerm(), pushTerm(), and translateBlock().

◆ merged_public_classes

RexxDirectory* RexxSource::merged_public_classes
protected

Definition at line 488 of file SourceFile.hpp.

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

◆ merged_public_routines

RexxDirectory* RexxSource::merged_public_routines
protected

Definition at line 490 of file SourceFile.hpp.

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

◆ methods

RexxDirectory* RexxSource::methods
protected

Definition at line 491 of file SourceFile.hpp.

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

◆ namedSubTerms

RexxQueue* RexxSource::namedSubTerms
protected

Definition at line 515 of file SourceFile.hpp.

Referenced by argArray(), argList(), callNew(), cleanup(), collectionMessage(), globalSetup(), live(), liveGeneral(), and message().

◆ operators

RexxQueue* RexxSource::operators
protected

Definition at line 516 of file SourceFile.hpp.

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

◆ package

PackageClass* RexxSource::package
protected

Definition at line 476 of file SourceFile.hpp.

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

◆ parentSource

RexxSource* RexxSource::parentSource
protected

Definition at line 477 of file SourceFile.hpp.

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

◆ parseOptions

KeywordEntry RexxSource::parseOptions
staticprotected
Initial value:
= {
KeywordEntry(CHAR_ARG, SUBKEY_ARG),
KeywordEntry(CHAR_CASELESS, SUBKEY_CASELESS),
KeywordEntry(CHAR_LINEIN, SUBKEY_LINEIN),
KeywordEntry(CHAR_LOWER, SUBKEY_LOWER),
KeywordEntry(CHAR_PULL, SUBKEY_PULL),
KeywordEntry(CHAR_SOURCE, SUBKEY_SOURCE),
KeywordEntry(CHAR_UPPER, SUBKEY_UPPER),
KeywordEntry(CHAR_VALUE, SUBKEY_VALUE),
KeywordEntry(CHAR_VAR, SUBKEY_VAR),
KeywordEntry(CHAR_VERSION, SUBKEY_VERSION),
}
SUBKEY_VAR
#define SUBKEY_VAR
Definition: Token.hpp:233
SUBKEY_LOWER
#define SUBKEY_LOWER
Definition: Token.hpp:217
SUBKEY_VERSION
#define SUBKEY_VERSION
Definition: Token.hpp:234
SUBKEY_SOURCE
#define SUBKEY_SOURCE
Definition: Token.hpp:227
SUBKEY_LINEIN
#define SUBKEY_LINEIN
Definition: Token.hpp:216
SUBKEY_UPPER
#define SUBKEY_UPPER
Definition: Token.hpp:231
SUBKEY_ARG
#define SUBKEY_ARG
Definition: Token.hpp:205
SUBKEY_PULL
#define SUBKEY_PULL
Definition: Token.hpp:225
SUBKEY_VALUE
#define SUBKEY_VALUE
Definition: Token.hpp:232
SUBKEY_CASELESS
#define SUBKEY_CASELESS
Definition: Token.hpp:218

Definition at line 543 of file SourceFile.hpp.

Referenced by parseOption().

◆ programDirectory

RexxString* RexxSource::programDirectory
protected

Definition at line 457 of file SourceFile.hpp.

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

◆ programExtension

RexxString* RexxSource::programExtension
protected

Definition at line 459 of file SourceFile.hpp.

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

◆ programFile

RexxString* RexxSource::programFile
protected

Definition at line 458 of file SourceFile.hpp.

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

◆ programName

RexxString* RexxSource::programName
protected

Definition at line 456 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 480 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 482 of file SourceFile.hpp.

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

◆ reserved1

intptr_t RexxSource::reserved1
protected

Definition at line 500 of file SourceFile.hpp.

◆ reserved2

intptr_t RexxSource::reserved2
protected

Definition at line 501 of file SourceFile.hpp.

◆ reserved3

intptr_t RexxSource::reserved3
protected

Definition at line 502 of file SourceFile.hpp.

◆ reserved4

intptr_t RexxSource::reserved4
protected

Definition at line 503 of file SourceFile.hpp.

◆ routines

RexxDirectory* RexxSource::routines
protected

Definition at line 479 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 507 of file SourceFile.hpp.

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

◆ securityManager

SecurityManager* RexxSource::securityManager
protected

Definition at line 460 of file SourceFile.hpp.

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

◆ sourceArray

RexxArray* RexxSource::sourceArray
protected

Definition at line 455 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 464 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 465 of file SourceFile.hpp.

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

◆ sourceLiterals

RexxList* RexxSource::sourceLiterals
protected

Definition at line 510 of file SourceFile.hpp.

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

◆ strings

RexxDirectory* RexxSource::strings
protected

Definition at line 511 of file SourceFile.hpp.

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

◆ subDirectives

KeywordEntry RexxSource::subDirectives
staticprotected
Initial value:
= {
KeywordEntry(CHAR_ABSTRACT, SUBDIRECTIVE_ABSTRACT),
KeywordEntry(CHAR_ATTRIBUTE, SUBDIRECTIVE_ATTRIBUTE),
KeywordEntry(CHAR_CLASS, SUBDIRECTIVE_CLASS),
KeywordEntry(CHAR_COMMANDS, SUBDIRECTIVE_COMMANDS),
KeywordEntry(CHAR_DIGITS, SUBDIRECTIVE_DIGITS),
KeywordEntry(CHAR_EXTERNAL, SUBDIRECTIVE_EXTERNAL),
KeywordEntry(CHAR_FORM, SUBDIRECTIVE_FORM),
KeywordEntry(CHAR_FUZZ, SUBDIRECTIVE_FUZZ),
KeywordEntry(CHAR_GET, SUBDIRECTIVE_GET),
KeywordEntry(CHAR_GUARDED, SUBDIRECTIVE_GUARDED),
KeywordEntry(CHAR_INHERIT, SUBDIRECTIVE_INHERIT),
KeywordEntry(CHAR_LIBRARY, SUBDIRECTIVE_LIBRARY),
KeywordEntry(CHAR_MACROSPACE, SUBDIRECTIVE_MACROSPACE),
KeywordEntry(CHAR_METACLASS, SUBDIRECTIVE_METACLASS),
KeywordEntry(CHAR_MIXINCLASS, SUBDIRECTIVE_MIXINCLASS),
KeywordEntry(CHAR_NOCOMMANDS, SUBDIRECTIVE_NOCOMMANDS),
KeywordEntry(CHAR_NOMACROSPACE,SUBDIRECTIVE_NOMACROSPACE),
KeywordEntry(CHAR_PACKAGE, SUBDIRECTIVE_PACKAGE),
KeywordEntry(CHAR_PRIVATE, SUBDIRECTIVE_PRIVATE),
KeywordEntry(CHAR_PROTECTED, SUBDIRECTIVE_PROTECTED),
KeywordEntry(CHAR_PUBLIC, SUBDIRECTIVE_PUBLIC),
KeywordEntry(CHAR_SET, SUBDIRECTIVE_SET),
KeywordEntry(CHAR_SUBCLASS, SUBDIRECTIVE_SUBCLASS),
KeywordEntry(CHAR_TRACE, SUBDIRECTIVE_TRACE),
KeywordEntry(CHAR_UNGUARDED, SUBDIRECTIVE_UNGUARDED),
KeywordEntry(CHAR_UNPROTECTED, SUBDIRECTIVE_UNPROTECTED),
}
SUBDIRECTIVE_NOCOMMANDS
#define SUBDIRECTIVE_NOCOMMANDS
Definition: Token.hpp:298
SUBDIRECTIVE_EXTERNAL
#define SUBDIRECTIVE_EXTERNAL
Definition: Token.hpp:282
SUBDIRECTIVE_LIBRARY
#define SUBDIRECTIVE_LIBRARY
Definition: Token.hpp:292
SUBDIRECTIVE_MIXINCLASS
#define SUBDIRECTIVE_MIXINCLASS
Definition: Token.hpp:285
SUBDIRECTIVE_PACKAGE
#define SUBDIRECTIVE_PACKAGE
Definition: Token.hpp:301
SUBDIRECTIVE_FORM
#define SUBDIRECTIVE_FORM
Definition: Token.hpp:294
SUBDIRECTIVE_COMMANDS
#define SUBDIRECTIVE_COMMANDS
Definition: Token.hpp:297
SUBDIRECTIVE_MACROSPACE
#define SUBDIRECTIVE_MACROSPACE
Definition: Token.hpp:299
SUBDIRECTIVE_SET
#define SUBDIRECTIVE_SET
Definition: Token.hpp:291
SUBDIRECTIVE_GUARDED
#define SUBDIRECTIVE_GUARDED
Definition: Token.hpp:280
SUBDIRECTIVE_UNGUARDED
#define SUBDIRECTIVE_UNGUARDED
Definition: Token.hpp:284
SUBDIRECTIVE_INHERIT
#define SUBDIRECTIVE_INHERIT
Definition: Token.hpp:278
SUBDIRECTIVE_SUBCLASS
#define SUBDIRECTIVE_SUBCLASS
Definition: Token.hpp:283
SUBDIRECTIVE_ATTRIBUTE
#define SUBDIRECTIVE_ATTRIBUTE
Definition: Token.hpp:286
SUBDIRECTIVE_UNPROTECTED
#define SUBDIRECTIVE_UNPROTECTED
Definition: Token.hpp:289
SUBDIRECTIVE_TRACE
#define SUBDIRECTIVE_TRACE
Definition: Token.hpp:296
SUBDIRECTIVE_FUZZ
#define SUBDIRECTIVE_FUZZ
Definition: Token.hpp:295
SUBDIRECTIVE_DIGITS
#define SUBDIRECTIVE_DIGITS
Definition: Token.hpp:293
SUBDIRECTIVE_NOMACROSPACE
#define SUBDIRECTIVE_NOMACROSPACE
Definition: Token.hpp:300
SUBDIRECTIVE_GET
#define SUBDIRECTIVE_GET
Definition: Token.hpp:290
SUBDIRECTIVE_ABSTRACT
#define SUBDIRECTIVE_ABSTRACT
Definition: Token.hpp:288
SUBDIRECTIVE_CLASS
#define SUBDIRECTIVE_CLASS
Definition: Token.hpp:281
SUBDIRECTIVE_PRIVATE
#define SUBDIRECTIVE_PRIVATE
Definition: Token.hpp:279
SUBDIRECTIVE_PUBLIC
#define SUBDIRECTIVE_PUBLIC
Definition: Token.hpp:276
SUBDIRECTIVE_METACLASS
#define SUBDIRECTIVE_METACLASS
Definition: Token.hpp:277
SUBDIRECTIVE_PROTECTED
#define SUBDIRECTIVE_PROTECTED
Definition: Token.hpp:287

Definition at line 544 of file SourceFile.hpp.

Referenced by subDirective().

◆ subKeywords

KeywordEntry RexxSource::subKeywords
staticprotected

Definition at line 540 of file SourceFile.hpp.

Referenced by subKeyword().

◆ subTerms

RexxQueue* RexxSource::subTerms
protected

Definition at line 514 of file SourceFile.hpp.

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

◆ terms

RexxQueue* RexxSource::terms
protected

Definition at line 513 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 423 of file SourceFile.hpp.

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

◆ TRACE_COMMANDS

const size_t RexxSource::TRACE_COMMANDS = 'C'
static

Definition at line 424 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 450 of file SourceFile.hpp.

◆ TRACE_ERRORS

const size_t RexxSource::TRACE_ERRORS = 'E'
static

Definition at line 428 of file SourceFile.hpp.

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

◆ TRACE_FAILURES

const size_t RexxSource::TRACE_FAILURES = 'F'
static

Definition at line 427 of file SourceFile.hpp.

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

◆ TRACE_IGNORE

const size_t RexxSource::TRACE_IGNORE = '0'
static

Definition at line 432 of file SourceFile.hpp.

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

◆ TRACE_INTERMEDIATES

const size_t RexxSource::TRACE_INTERMEDIATES = 'I'
static

Definition at line 430 of file SourceFile.hpp.

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

◆ TRACE_LABELS

const size_t RexxSource::TRACE_LABELS = 'L'
static

Definition at line 425 of file SourceFile.hpp.

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

◆ TRACE_NORMAL

const size_t RexxSource::TRACE_NORMAL = 'N'
static

Definition at line 426 of file SourceFile.hpp.

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

◆ TRACE_OFF

const size_t RexxSource::TRACE_OFF = 'O'
static

Definition at line 431 of file SourceFile.hpp.

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

◆ TRACE_RESULTS

const size_t RexxSource::TRACE_RESULTS = 'R'
static

Definition at line 429 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 437 of file SourceFile.hpp.

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

◆ traceFlags

size_t RexxSource::traceFlags
protected

Definition at line 497 of file SourceFile.hpp.

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

◆ traceSetting

size_t RexxSource::traceSetting
protected

Definition at line 496 of file SourceFile.hpp.

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

◆ variableindex

size_t RexxSource::variableindex
protected

Definition at line 533 of file SourceFile.hpp.

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

◆ variables

RexxDirectory* RexxSource::variables
protected

Definition at line 526 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: