81 #include "SystemInterpreter.hpp"
89 #include "SysFileSystem.hpp"
102 #define line_delimiters "\r\n"
190 const char *_current;
205 if (start[0] ==
'#' && start[1] ==
'!')
207 memcpy(start,
"--", 2);
213 indices->
copyData(&descriptor,
sizeof(descriptor));
216 scan = (
const char *)memchr(start,
ctrl_z, length);
219 length = scan - start;
226 descriptor.
position = _current - start;
230 while (scan !=
OREF_NULL && *scan ==
'\0')
237 _current = _current + length;
238 descriptor.
length = length;
244 descriptor.
length = scan - _current;
250 if (length > (
size_t)(scan - _current))
263 length -= scan - _current;
267 indices->
copyData(&descriptor,
sizeof(descriptor));
294 memcpy(begin,program_source->
getData(), 9);
297 begin[9]=end[3]=0x00;
300 memcpy(program_source->
getData(),
" ", 9);
526 const char *buffer_start;
822 const char *buffer_start;
826 return OREF_NULLSTRING;
851 return new_string(buffer_start + descriptors[_position].
position, descriptors[_position].length);
855 return OREF_NULLSTRING;
860 #define dumpClause(from, source, clause) dumpClauseImpl(from, source, clause)
862 #define dumpClause(from, source, clause)
872 dbgprintf(
"(Parsing)-------------------------------------------------\n");
882 #define dumpTokens(from, source, clause) dumpTokensImpl(from, source, clause)
884 #define dumpTokens(from, source, clause)
895 for (
size_t i=1; i < clause->
free; i++)
901 if (token->
value == NULL)
948 location = token_location;
964 location.
setEnd(token_location);
968 this->
flags &= ~reclaimed;
979 #define TRACE_OVERHEAD 16
983 #define INSTRUCTION_OVERHEAD 11
985 #define PREFIX_OFFSET (LINENUMBER + 1)
986 #define PREFIX_LENGTH 3
987 #define INDENT_SPACING 2
1019 size_t indent,
bool trace)
1025 char linenumber[11];
1033 if (
line == OREF_NULLSTRING)
1068 outlength = strlen(linenumber);
1069 linepointer = linenumber;
1079 buffer->
put(
LINENUMBER - outlength, linepointer, outlength);
1100 return OREF_NULLSTRING;
1104 line = OREF_NULLSTRING;
1198 source->
put(source_line, 1);
1212 source->
put(source_line, 1);
1230 source->
put(source_line, i);
1310 size_t _line_number,
1319 source->
adjustLine(_line_number, _line_number);
1365 bool result =
false;
1607 return routineObject;
1806 _requires->
install(activation);
1828 createdClasses->
put(newClass, index++);
1831 for (
size_t j = 1; j < index; j++)
1845 current_extension->
install(
this, activation);
1901 while (!this->
atEnd())
1958 next_install = current_class;
2020 #define DEFAULT_GUARD 0
2021 #define GUARDED_METHOD 1
2022 #define UNGUARDED_METHOD 2
2024 #define DEFAULT_PROTECTION 0
2025 #define PROTECTED_METHOD 1
2026 #define UNPROTECTED_METHOD 2
2028 #define DEFAULT_ACCESS_SCOPE 0
2029 #define PUBLIC_SCOPE 1
2030 #define PRIVATE_SCOPE 2
2101 this->active_class->setMetaClass(token->
value);
2113 this->active_class->setPublic();
2140 this->active_class->setSubClass(token->
value);
2158 this->active_class->setMixinClass(token->
value);
2178 this->active_class->addInherits(token->
value);
2257 this->active_extension->addInherits(token->
value);
2353 bool Attribute =
false;
2354 bool abstractMethod =
false;
2401 if (externalname !=
OREF_NULL || abstractMethod)
2413 externalname = token->
value;
2500 if (abstractMethod || externalname !=
OREF_NULL)
2505 if (externalname !=
OREF_NULL || Attribute)
2509 abstractMethod =
true;
2548 addMethod(internalname, _method, Class);
2569 else if (abstractMethod)
2607 addMethod(internalname, _method, Class);
2815 procedure = methodName;
2821 if (((
RexxString *)(_words->
get(1)))->strCompare(CHAR_LIBRARY))
2824 if (_words->
size() == 3)
2829 else if (_words->
size() == 2)
2846 #define ATTRIBUTE_BOTH 0
2847 #define ATTRIBUTE_GET 1
2848 #define ATTRIBUTE_SET 2
2861 bool abstractMethod =
false;
2990 if (externalname !=
OREF_NULL || abstractMethod)
3002 externalname = token->
value;
3007 if (abstractMethod || externalname !=
OREF_NULL)
3011 abstractMethod =
true;
3051 addMethod(internalname, _method, Class);
3059 else if (abstractMethod)
3093 if (internalname == procedure)
3096 p_procedure = procedure;
3102 addMethod(internalname, _method, Class);
3105 else if (abstractMethod)
3145 if (internalname == procedure)
3148 p_procedure = procedure;
3157 else if (abstractMethod)
3273 bool privateMethod,
bool protectedMethod,
bool guardedMethod)
3286 _method->
setAttributes(privateMethod, protectedMethod, guardedMethod);
3307 bool classMethod,
bool privateMethod,
bool protectedMethod,
bool guardedMethod)
3312 _method->
setAttributes(privateMethod, protectedMethod, guardedMethod);
3332 bool classMethod,
bool privateMethod,
bool protectedMethod,
bool guardedMethod)
3337 _method->
setAttributes(privateMethod, protectedMethod, guardedMethod);
3357 bool classMethod,
bool privateMethod,
bool protectedMethod,
bool guardedMethod)
3363 _method->
setAttributes(privateMethod, protectedMethod, guardedMethod);
3452 externalname = token->
value;
3491 if (((
RexxString *)(_words->
get(1)))->strCompare(CHAR_LIBRARY))
3498 if (_words->
size() == 3)
3503 else if (_words->
size() == 2)
3534 else if (((
RexxString *)(_words->
get(1)))->strCompare(CHAR_REGISTERED))
3541 if (_words->
size() == 3)
3546 else if (_words->
size() == 2)
3742 second = this->
popDo();
3756 second = this->
popDo();
3829 this->
pushDo(_instruction);
3878 type = _instruction->
getType();
3911 second = this->
topDo();
3929 if (this->
flags&no_clause)
3950 if (this->
flags&no_clause)
3973 if (this->
flags&no_clause)
3990 second = this->
topDo();
3997 second = this->
popDo();
3998 this->
pushDo(_instruction);
4009 if (this->
flags&no_clause)
4024 second = this->
topDo();
4032 this->
pushDo(_instruction);
4046 second = this->
popDo();
4069 second = this->
popDo();
4087 this->
pushDo(_instruction);
4091 this->
pushDo(_instruction);
4107 if (
isOfClass(FunctionCallTerm, _instruction))
4175 return _instruction;
4242 return _instruction;
4257 return _instruction;
4283 _instruction = this->
nopNew();
4289 _instruction = this->
dropNew();
4301 _instruction = this->
callNew();
4331 _instruction = this->
doNew();
4337 _instruction = this->
loopNew();
4343 _instruction = this->
exitNew();
4400 if (this->
flags&_interpret)
4409 if (this->
flags&_interpret)
4424 if (this->
flags&_interpret)
4433 if (this->
flags&_interpret)
4436 _instruction = this->
useNew();
4460 _instruction = this->
sayNew();
4490 _instruction = this->
elseNew(_first);
4496 _instruction = this->
endNew();
4518 return _instruction;
4606 const char * _position;
4613 end = _position + length;
4617 while (*_position !=
'.')
4623 stemRetriever = this->
addStem(stemName);
4635 while (_position < end)
4637 if (*_position ==
'.')
4647 if (!(tail->
getBLength() == 0 || (*start >=
'0' && *start <=
'9')))
4658 }
while (_position < end);
4817 PackageClass *
package = this->isInterpret() ? this->interpret_activation->getPackage() : this->getPackage();
4981 _expression = this->
addText(token);
4985 _expression = this->
addText(token);
4989 _expression = this->
addText(token);
5035 _expression = this->
addText(token);
5039 _expression = this->
addText(token);
5043 _expression = this->
addText(token);
5196 while (!this->
terminator(terminators, token))
5348 bool namedArgumentAllowed,
5356 size_t namedArgCount=0;
5360 this->
argList(_first, terminators, namedArgumentAllowed, argCount, namedArgCount);
5365 while (argCount > 0)
5371 _namedArgArray =
new_array(2 * namedArgCount);
5374 while (namedArgCount > 0)
5388 bool namedArgumentAllowed,
5389 size_t &positionalArgumentCount,
5390 size_t &namedArgumentCount)
5427 bool namedArgument =
false;
5433 arglist->
push(expr);
5434 positionalArgumentCount = 1;
5435 namedArgumentCount = 0;
5468 arglist->
push(subexpr);
5481 new_string(
"Named argument: expected symbol followed by colon"));
5491 new_string(
"Named argument: expected symbol followed by colon"));
5496 new_string(
"Named argument: expected expression after colon"));
5497 namedArglist->
push(subexpr);
5524 this->
popNTerms(total + ((2 * namedTotal)));
5546 arglist->
push(expr);
5553 positionalArgumentCount = total;
5554 namedArgumentCount = namedTotal;
5569 size_t namedArgCount=0;
5578 _function =
new (argCount + (2 * namedArgCount))
RexxExpressionFunction(name->
value, argCount, this->subTerms, namedArgCount, this->namedSubTerms, this->resolveBuiltin(name->
value), name->
isLiteral());
5597 size_t namedArgCount=0;
5620 size_t namedArgCount=0;
5662 size_t namedArgCount;
5664 bool messagenameProvided =
true;
5678 token = this->
getToken(terminators, 0 );
5683 messagename = (
RexxString *)OREF_TILDE_ROUND_BRACKETS;
5684 messagenameProvided =
false;
5689 messagename = token->
value;
5697 token = this->
getToken(terminators, 0);
5713 token = this->
getToken(terminators, 0);
5716 if (!messagenameProvided)
5771 result = this->
addText(_first);
5969 term = this->
function(second, token, terminators);
6141 wordlist->
push(word);
6148 wordlist->
push(word);
6156 wordarray->
put(wordlist->
pop(), count--);
6283 const char *newline = strchr(
string,
'\n');
6340 switch (_instruction->
getType())
6371 void *RexxSource::operator
new (
size_t size)
6424 for (
size_t _position = 0; _position < length; _position++)
6428 switch (value->
getCharB(_position))
6491 badOption = value->
getCharB(_position);
6499 newSetting = setting | debug;
6565 retriever = this->
addText(token);
6596 retriever = this->
addText(token);
6635 if (list_count == 0)
6656 int *condition_type,
6727 if (condition_type != NULL)
6729 *condition_type = _keyword;
6750 argList(_first, terminators,
false, count, namedCount);
6798 return packageInstance;
6822 return packageInstance;
void reportException(wholenumber_t error)
RexxArray * new_array(size_t s)
RexxBuffer * new_buffer(sizeB_t s)
RexxDirectory * new_directory()
RexxIdentityTable * new_identity_table()
RexxInteger * new_integer(wholenumber_t v)
#define TheCommonRetrievers
bool isMethod(RexxObject *o)
#define Error_Translation_body_error
#define Error_Invalid_expression_until
#define Error_Translation_external_routine
#define Error_Translation_invalid_line
#define Error_Unexpected_then_else
#define Error_Symbol_or_string_fuzz_value
#define Error_Translation_bad_external
#define Error_Symbol_or_string_external
#define Error_Symbol_or_string_constant_value
#define Message_Translations_no_source_available
#define Error_Symbol_or_string_constant
#define Error_Unmatched_parenthesis_square
#define Error_Translation_constant_body
#define Error_Symbol_expected_colon
#define Error_Translation_attribute_method
#define Error_Translation_reply_interpret
#define Error_Invalid_subkeyword_method
#define Error_Symbol_or_string_trace_value
#define Error_Invalid_subkeyword_requires
#define Error_Invalid_expression_message_term
#define Error_Invalid_variable_period
#define Error_Execution_cyclic
#define Error_Unexpected_end_else
#define Error_Unexpected_comma_paren
#define Error_Unmatched_parenthesis_paren
#define Error_Translation_duplicate_constant
#define Error_Symbol_or_string_mixinclass
#define Error_Unexpected_comma_bracket
#define Error_Invalid_subkeyword_class
#define Error_Invalid_do_whileuntil
#define Error_External_name_not_found_routine
#define Error_Unexpected_end_then
#define Error_Translation_directive_interpret
#define Error_Program_unreadable_name
#define Error_Invalid_trace_trace
#define Error_Invalid_subkeyword_attribute
#define Error_Incomplete_do_otherwise
#define Error_Unexpected_comma_comma
#define Error_Routine_not_found_requires
#define Error_Symbol_or_string_attribute
#define Error_Symbol_or_string_inherit
#define Error_Invalid_expression_after_tilde
#define Error_Invalid_variable_number
#define Error_Symbol_or_string_digits_value
#define Error_Translation_bad_directive
#define Error_Symbol_or_string_routine
#define Error_Symbol_expected_varref
#define Error_Invalid_expression_general
#define Error_Symbol_expected_expose
#define Error_Translation_expose_interpret
#define Error_Translation_forward_interpret
#define Error_Symbol_or_string_subclass
#define Error_Symbol_expected_drop
#define Error_Invalid_subkeyword_options
#define Error_Translation_external_method
#define Error_Invalid_data_constant_dir
#define Error_Invalid_expression_prefix
#define Error_Symbol_expected_upper
#define Error_Translation_duplicate_attribute
#define Error_Translation_abstract_attribute
#define Error_Unexpected_when_when
#define Error_Symbol_or_string_method
#define Error_Symbol_or_string_requires
#define Error_Translation_external_attribute
#define Error_Then_expected_if
#define Error_Unexpected_then_then
#define Error_Variable_reference_missing
#define Error_Symbol_expected_directive
#define Error_Symbol_or_string_class
#define Error_Symbol_or_string_metaclass
#define Error_Expression_result_digits
#define Error_Translation_use_interpret
#define Error_Incomplete_do_then
#define Error_Incomplete_do_else
#define Error_Translation_missing_class
#define Error_When_expected_whenotherwise
#define Error_Invalid_subkeyword_routine
#define Error_Invalid_whole_number_fuzz
#define Error_Translation_invalid_attribute
#define Message_Translations_internal_code
#define Error_Unexpected_end_nodo
#define Error_Translation_guard_interpret
#define Error_External_name_not_found_method
#define Error_Unexpected_label_interpret
#define Error_Translation_abstract_method
#define Error_Invalid_expression_user_defined
#define Error_Incomplete_do_do
#define Error_Variable_reference_extra
#define Error_Unexpected_when_otherwise
#define Error_Translation_duplicate_method
#define Error_Invalid_expression_while
#define Error_Incomplete_do_loop
#define Error_Translation_duplicate_routine
#define Error_Invalid_whole_number_digits
#define Error_Translation_duplicate_class
#define Error_Translation_expose
#define Error_Invalid_subkeyword_form
#define Error_Incomplete_do_select
#define FIRST_VARIABLE_INDEX
#define memory_mark(oref)
RexxObject * new_object(size_t s)
#define flatten_reference(oref, envel)
#define memory_mark_general(oref)
#define setUpFlatten(type)
#define DEFAULT_PROTECTION
#define dumpClause(from, source, clause)
#define dumpTokens(from, source, clause)
#define DEFAULT_ACCESS_SCOPE
#define UNPROTECTED_METHOD
void dumpTokensImpl(const char *from, RexxSource *source, RexxClause *clause)
#define INSTRUCTION_OVERHEAD
struct _LINE_DESCRIPTOR LINE_DESCRIPTOR
void dumpClauseImpl(const char *from, RexxSource *source, RexxClause *clause)
RexxString * new_string(const char *s, stringsizeB_t bl, sizeC_t cl=-1)
#define STRING_COMPOUND_NAME
RexxString * raw_string(stringsizeB_t bl, stringsizeC_t cl=-1)
#define SUBDIRECTIVE_NOCOMMANDS
#define SUBDIRECTIVE_EXTERNAL
#define KEYWORD_OTHERWISE
#define SUBDIRECTIVE_LIBRARY
#define SUBKEY_SCIENTIFIC
#define SUBDIRECTIVE_MIXINCLASS
#define OPERATOR_SUBTRACT
#define SUBDIRECTIVE_FORM
#define OPERATOR_BACKSLASH
#define SUBDIRECTIVE_COMMANDS
#define DIRECTIVE_EXTENSION
#define SUBDIRECTIVE_MACROSPACE
#define DIRECTIVE_REQUIRES
#define SUBDIRECTIVE_GUARDED
#define DIRECTIVE_ROUTINE
#define KEYWORD_PROCEDURE
#define SUBDIRECTIVE_UNGUARDED
#define SUBDIRECTIVE_INHERIT
#define SUBDIRECTIVE_SUBCLASS
#define SUBDIRECTIVE_ATTRIBUTE
#define refineSubclass(token, refinedSubclass)
#define SUBKEY_ENGINEERING
#define SUBDIRECTIVE_UNPROTECTED
#define OPERATOR_STRICT_EQUAL
#define SUBDIRECTIVE_TRACE
#define SUBDIRECTIVE_FUZZ
#define SUBDIRECTIVE_DIGITS
#define SUBDIRECTIVE_NOMACROSPACE
#define DIRECTIVE_ATTRIBUTE
#define SUBDIRECTIVE_ABSTRACT
#define DIRECTIVE_OPTIONS
#define SUBDIRECTIVE_CLASS
#define SUBDIRECTIVE_PRIVATE
#define KEYWORD_INTERPRET
#define SUBDIRECTIVE_PUBLIC
#define SUBDIRECTIVE_METACLASS
#define DIRECTIVE_CONSTANT
#define SUBDIRECTIVE_PROTECTED
#define TOKEN_SOURCE_LITERAL
#define CONCURRENCY_TRACE
static RexxObject * getLocalEnvironment(RexxString *name)
static RexxActivity *volatile currentActivity
BaseExecutable * setSourceObject(RexxSource *s)
RexxString * getMetaClass()
void removeDependency(RexxString *name)
bool checkDuplicateMethod(RexxString *name, bool classMethod)
RexxClass * install(RexxSource *source, RexxActivation *activation)
RexxString * getSubClass()
void addConstantMethod(RexxString *name, RexxMethod *method)
void addMethod(RexxString *name, RexxMethod *method, bool classMethod)
bool dependenciesResolved()
void addDependencies(RexxDirectory *class_directives)
void addMethod(RexxString *name, RexxMethod *method, bool classMethod)
bool checkDuplicateMethod(RexxString *name, bool classMethod)
void addConstantMethod(RexxString *name, RexxMethod *method)
void install(RexxSource *source, RexxActivation *activation)
PackageClass * loadRequires(RexxActivity *activity, RexxString *shortName, const char *data, size_t length)
RexxString * resolveProgramName(RexxString *name, RexxString *dir, RexxString *ext)
void install(RexxActivation *context)
static const bool DEFAULT_FORM
static const bool FORM_SCIENTIFIC
static const size_t DEFAULT_FUZZ
static const bool FORM_ENGINEERING
static const size_t DEFAULT_DIGITS
RexxSource * getSourceObject()
static RoutineClass * resolveRoutine(RexxString *function, RexxString *packageName, RexxString *procedure)
static RexxNativeMethod * resolveMethod(RexxString *packageName, RexxString *methodName)
void install(RexxActivation *context)
RexxString * formatSourcelessTraceLine(RexxString *packageName)
static const bool default_enable_macrospace
static size_t processTraceSetting(size_t traceSetting)
static const size_t default_trace_flags
static const bool default_enable_commands
void raiseException(wholenumber_t, RexxString *, RexxArray *, RexxObject *)
RexxString * buildMessage(wholenumber_t, RexxArray *)
InterpreterInstance * getInstance()
void put(RexxObject *eref, size_t pos)
RexxObject * get(size_t pos)
void setEnd(size_t, sizeB_t)
void setStart(size_t, sizeB_t)
SourceLocation clauseLocation
const SourceLocation & getLocation()
void setLocation(SourceLocation &l)
RexxObject * setEntry(RexxString *, RexxObject *)
RexxObject * put(RexxObject *, RexxString *)
RexxObject * fastAt(RexxString *name)
RexxObject * entry(RexxString *)
bool available(HashLink pos)
RexxObject * value(HashLink pos)
HashLink next(HashLink pos)
RexxObject * index(HashLink pos)
virtual RexxObject * put(RexxObject *, RexxObject *)
virtual RexxObject * remove(RexxObject *key)
SourceLocation instructionLocation
const SourceLocation & getLocation()
void setNext(RexxInstruction *next)
uint16_t instructionFlags
RexxInstruction * nextInstruction
void setBehaviour(RexxBehaviour *b)
RexxObject * removeIndex(size_t i)
RexxObject * append(RexxObject *)
size_t nextIndex(size_t i)
RexxObject * hasItem(RexxObject *)
RexxObject * removeFirst()
RexxObject * getValue(size_t i)
RexxDirectory * getGlobalStrings()
void setAttributes(bool _private, bool _protected, bool _guarded)
virtual BaseCode * setSourceObject(RexxSource *s)
RexxNumberString * numberString()
bool requestUnsignedNumber(stringsize_t &, size_t)
RexxInteger * requestInteger(size_t)
void sendMessage(RexxString *, RexxArray *, RexxDirectory *, ProtectedObject &)
void push(RexxObject *obj)
void queue(RexxObject *obj)
size_t copyData(void *, size_t)
RexxInstruction * loopNew()
RexxStemVariable * addStem(RexxString *)
void createAttributeGetterMethod(RexxString *name, RexxVariableBase *retriever, bool classMethod, bool privateMethod, bool protectedMethod, bool guardedMethod)
RexxDirectory * class_dependencies
void resetPosition(size_t p)
RexxObject * subExpression(int)
static const size_t TRACE_COMMANDS
void pushDo(RexxInstruction *i)
void createConstantGetterMethod(RexxString *name, RexxObject *value)
PackageClass * loadRequires(RexxActivity *activity, RexxString *target)
static const size_t TRACE_ERRORS
RexxToken * sourceNextToken(RexxToken *)
RexxList * sourceLiterals
RexxToken * popOperator()
static int subDirective(RexxToken *)
RexxInstruction * labelNew()
void decodeExternalMethod(RexxString *methodName, RexxString *externalSpec, RexxString *&library, RexxString *&procedure)
static int keyDirective(RexxToken *)
RexxDirectory * public_routines
RexxObject * parseLogical(RexxToken *first, int terminators)
RexxCode * translateBlock(RexxDirectory *)
RexxInstruction * forwardNew()
static const size_t TRACE_INTERMEDIATES
RexxInstruction * traceNew()
static const size_t TRACE_SETTING_MASK
RexxObject * collectionMessage(RexxToken *, RexxObject *, int)
void extensionDirective()
RexxInstruction * ifNew(int)
RexxString * programDirectory
void addClause(RexxInstruction *)
static int precedence(RexxToken *)
RexxString * programExtension
void argList(RexxToken *, int, bool, size_t &, size_t &)
RexxCode * interpret(RexxString *, RexxDirectory *, size_t, RexxActivation *)
RexxMethod * createNativeMethod(RexxString *name, RexxString *library, RexxString *procedure)
void resolveDependencies()
RexxObject * expression(int)
RexxInstruction * messageAssignmentNew(RexxExpressionMessage *, RexxObject *)
void checkDuplicateMethod(RexxString *name, bool classMethod, int errorMsg)
void extractNameInformation()
RexxInstruction * exitNew()
RexxString * traceBack(RexxActivation *, SourceLocation &, size_t, bool)
RexxInstruction * findLabel(RexxString *)
RexxInstruction * topDo()
RexxInstruction * exposeNew()
void flatten(RexxEnvelope *)
RexxSource * parentSource
RexxInstruction * instruction()
static int subKeyword(RexxToken *)
RexxObject * fullSubExpression(int)
void syntaxError(int errorcode, RexxInstruction *i)
RexxObject * popNTerms(size_t)
RexxString * resolveProgramName(RexxActivity *activity, RexxString *name)
RoutineClass * findPublicRoutine(RexxString *)
RexxInstruction * elseNew(RexxToken *)
RexxInstruction * raiseNew()
RexxObject * messageSubterm(int)
SourceLocation clauseLocation
RexxInstruction * assignmentNew(RexxToken *)
RexxArray * extractSource()
RexxToken * getToken(int, int)
RexxObject * messageTerm()
RexxObject * subTerm(int)
static const size_t TRACE_LABELS
RexxInstruction * messageAssignmentOpNew(RexxExpressionMessage *, RexxToken *, RexxObject *)
void addLabel(RexxInstruction *, RexxString *)
RexxVariableBase * getRetriever(RexxString *)
ExtensionDirective * active_extension
void pushOperator(RexxToken *operatorToken)
RexxObject * functionCallMessage(RexxToken *, RexxObject *, int)
void libraryDirective(RexxString *name, RexxToken *token)
ClassDirective * active_class
RexxObject * toss(RexxObject *)
void syntaxErrorAt(int errorcode, RexxToken *token)
void errorLine(int, RexxInstruction *)
RexxInstruction * signalNew()
RexxObject * parseConditional(int *, int)
RexxInstruction * leaveNew(int)
void createAttributeSetterMethod(RexxString *name, RexxVariableBase *retriever, bool classMethod, bool privateMethod, bool protectedMethod, bool guardedMethod)
RexxActivation * interpret_activation
void createAbstractMethod(RexxString *name, bool classMethod, bool privateMethod, bool protectedMethod, bool guardedMethod)
RexxInstruction * addressNew()
RexxCompoundVariable * addCompound(RexxString *)
RexxInstruction * numericNew()
void addReference(RexxObject *reference)
SecurityManager * securityManager
RexxInstruction * upperNew()
StackFrameClass * createStackFrame()
void pushSubTerm(RexxObject *)
RexxCode * translate(RexxDirectory *)
RexxInstruction * endNew()
RexxCode * generateCode(bool isMethod)
void addInstalledRoutine(RexxString *name, RoutineClass *routineObject, bool publicRoutine)
RexxObject * constantLogicalExpression()
static const size_t DEBUG_ON
void removeObj(RexxObject *object)
RexxList * loadedPackages
RexxInstruction * parseNew(int)
void blockSyntaxError(RexxInstruction *i)
void errorToken(int, RexxToken *)
void argArray(RexxToken *, int, bool, RexxArray *&, RexxArray *&)
static RexxString * formatTraceSetting(size_t source)
RexxInstruction * useNew()
RexxInstruction * thenNew(RexxToken *, RexxInstructionIf *)
RexxCode * interpretMethod(RexxDirectory *, RexxActivation *)
RexxToken * topOperator()
void liveGeneral(int reason)
RexxInstruction * returnNew()
RoutineClass * findRoutine(RexxString *)
RexxInstruction * dropNew()
static const size_t TRACE_IGNORE
static const size_t DEBUG_OFF
void blockError(RexxInstruction *)
RexxInstruction * optionsNew()
void adjustLine(size_t, size_t)
void expose(RexxString *)
RexxInstruction * messageNew(RexxExpressionMessage *)
RexxInstruction * replyNew()
RexxString * commonString(RexxString *)
RexxInstruction * popDo()
RexxSource(RexxString *, RexxArray *)
void addInstalledClass(RexxString *name, RexxClass *classObject, bool publicClass)
RexxInstruction * interpretNew()
RexxInstruction * sourceNewObject(size_t, RexxBehaviour *, int)
RexxString * extract(SourceLocation &, bool=false)
size_t processVariableList(int)
RexxClass * findPublicClass(RexxString *name)
RexxObject * constantExpression()
RexxInstruction * doNew()
PackageClass * getPackage()
void errorPosition(int, SourceLocation)
RexxDirectory * variables
RexxInstruction * commandNew()
void pushTerm(RexxObject *)
static const size_t TRACE_NORMAL
void createMethod(RexxString *name, bool classMethod, bool privateMethod, bool protectedMethod, bool guardedMethod)
RexxInstruction * nopNew()
void holdObject(RexxObject *object)
void addMethod(RexxString *name, RexxMethod *method, bool classMethod)
RexxObject * message(RexxObject *, bool, int)
RexxObject * variableOrMessageTerm()
void mergeRequired(RexxSource *)
RexxDirectory * installed_classes
void initBuffered(RexxBuffer *)
RexxInstruction * queueNew(int)
RexxInstruction * sayNew()
void setProgramName(RexxString *name)
RexxInstruction * assignmentOpNew(RexxToken *, RexxToken *)
RexxObject * popSubTerm()
void saveObject(RexxObject *object)
RexxVariableBase * addVariable(RexxString *)
static const size_t TRACE_RESULTS
void needVariableOrDotSymbol(RexxToken *)
RexxIdentityTable * guard_variables
RexxDirectory * installed_public_classes
void checkDirective(int errorCode)
void processInstall(RexxActivation *)
RexxIdentityTable * savelist
void inheritSourceContext(RexxSource *source)
RexxInstruction * otherwiseNew(RexxToken *)
RexxInstruction * currentInstruction
RexxClass * findInstalledClass(RexxString *name)
void flushControl(RexxInstruction *)
RexxObject * function(RexxToken *, RexxToken *, int)
RexxDirectory * merged_public_classes
static const size_t TRACE_OFF
RexxBuffer * sourceBuffer
RexxDirectory * merged_public_routines
RexxDirectory * exposed_variables
RexxInstruction * guardNew()
RexxInstruction * endIfNew(RexxInstructionIf *)
RexxObject * parenExpression(RexxToken *)
void attributeDirective()
void position(size_t, sizeB_t)
RexxQueue * namedSubTerms
RexxArray * words(RexxString *)
RexxClass * findClass(RexxString *)
static const size_t DEBUG_IGNORE
void needVariable(RexxToken *)
RexxObject * addText(RexxToken *)
bool terminator(int, RexxObject *)
static const size_t TRACE_ALL
static bool parseTraceSetting(RexxString *, size_t &, size_t &, char &)
void addPackage(PackageClass *package)
static const size_t DEFAULT_TRACE_SETTING
static const size_t DEBUG_TOGGLE
RoutineClass * findLocalRoutine(RexxString *)
RexxInstruction * procedureNew()
static const size_t TRACE_FAILURES
RexxInstruction * selectNew()
RexxInstruction * callNew()
RexxBuffer * sourceIndices
RexxString * stringValue()
RexxString * extractB(sizeB_t offset, sizeB_t sublength)
const char * getStringData()
void setNumberString(RexxObject *)
RexxString * word(RexxInteger *)
RexxString * concatWithCstring(const char *)
RexxString * concat(RexxString *)
void set(sizeB_t s, int c, sizeB_t l)
RexxString * concatToCstring(const char *)
void put(sizeB_t s, const void *b, sizeB_t l)
codepoint_t getCharC(sizeC_t p)
SourceLocation tokenLocation
static const char * keywordText(int code)
static const char * codeText(int code)
const SourceLocation & getLocation()
bool isType(TokenClass t)
static RexxObject * buildCompoundVariable(RexxString *variable_name, bool direct)
void call(RexxActivity *, RexxString *, RexxObject **, size_t, size_t, RexxString *, RexxString *, int, ProtectedObject &)
RexxObject * checkEnvironmentAccess(RexxString *index)
RexxObject * checkLocalAccess(RexxString *index)
sizeB_t getOffset() const
size_t getEndLine() const
void setOffset(sizeB_t l)
size_t getLineNumber() const
void setEnd(SourceLocation &l)
void setEndOffset(sizeB_t l)
void setEndLine(size_t l)
sizeB_t getEndOffset() const
void setLineNumber(size_t l)
bool isLimitedTrace() const
void setLimitedTrace(bool b)
static RexxString * extractFile(RexxString *file)
static RexxString * extractDirectory(RexxString *file)
static RexxString * extractExtension(RexxString *file)
static RexxBuffer * readProgram(const char *file_name)
static wholenumber_t currentThreadId()
static bool traceConcurrency()
static bool traceParsing()
static int strCaselessCompare(const char *opt1, const char *opt2)
static const char * locateCharacter(const char *s, const char *set, sizeB_t l)
void dbgprintf(const char *format,...)