146 this->
sendMessage(OREF_STRICT_EQUAL, other, result);
285 return method_object;
389 return ((
RexxObject *)result)->stringValue()->getObjectHashCode();
495 void *RexxInternalObject::operator
new(
size_t size,
504 newObject->
setBehaviour(classObject->getInstanceBehaviour());
505 return(
void *)newObject;
508 void *RexxInternalObject::operator
new(
size_t size,
512 size_t named_argCount)
520 newObject->
setBehaviour(classObject->getInstanceBehaviour());
605 if (((
RexxClass *)sender)->isCompatibleWith(scope))
625 this->
sendMessage(message, args, argCount, named_argCount, r);
647 this->
sendMessage(message, argument1, argument2, r);
655 this->
sendMessage(message, argument1, argument2, argument3, r);
663 this->
sendMessage(message, argument1, argument2, argument3, argument4, r);
671 this->
sendMessage(message, argument1, argument2, argument3, argument4, argument5, r);
691 size_t argumentsCount = arguments ? arguments->
size() : 0;
696 this->
messageSend(message, args->
data(), argumentsCount, namedArgumentsCount, result);
703 arguments[0] = argument1;
704 this->
messageSend(message, arguments, 1, 0, result);
718 arguments[0] = argument1;
719 arguments[1] = argument2;
721 this->
messageSend(message, arguments, 2, 0, result);
736 arguments[0] = argument1;
737 arguments[1] = argument2;
738 arguments[2] = argument3;
740 this->
messageSend(message, arguments, 3, 0, result);
756 arguments[0] = argument1;
757 arguments[1] = argument2;
758 arguments[2] = argument3;
759 arguments[3] = argument4;
761 this->
messageSend(message, arguments, 4, 0, result);
778 arguments[0] = argument1;
779 arguments[1] = argument2;
780 arguments[2] = argument3;
781 arguments[3] = argument4;
782 arguments[4] = argument5;
784 this->
messageSend(message, arguments, 5, 0, result);
827 this->
processUnknown(msgname, arguments, count, named_count, result);
871 this->
processUnknown(msgname, arguments, count, named_count, result);
923 for (
size_t i = 1; i <= count; i++)
925 argumentArray->
put(arguments[i - 1], i);
935 unknown_arguments[0] = messageName;
937 unknown_arguments[1] = argumentArray;
938 unknown_arguments[2] = OREF_NAMEDARGUMENTS;
939 unknown_arguments[3] = namedArgumentDirectory ? namedArgumentDirectory :
TheNilObject;
1080 return OREF_NULLSTRING;
1192 return string_value;
1198 this->
sendMessage(OREF_REQUEST, OREF_STRINGSYM, string_value);
1201 string_value = ((
RexxObject *)string_value)->primitiveMakeString();
1252 return string_value;
1257 this->
sendMessage(OREF_REQUEST, OREF_STRINGSYM, string_value);
1284 string_value = this->
sendMessage(OREF_REQUEST, OREF_STRINGSYM);
1312 string_value = this->
sendMessage(OREF_REQUEST, OREF_STRINGSYM);
1561 this->
sendMessage(OREF_DEFAULTNAME, string_value);
1681 this->
defMethod(msgname, methobj, option);
1745 RexxObject **named_arglist,
size_t named_argcount)
1755 size_t count = arguments->
size();
1764 expectedNamedArguments.
check(named_arglist, named_argcount,
true,
false);
1768 size_t named_count = 0;
1773 p_named_arguments_value = named_arguments_value;
1780 named_count = named_arguments_value->
items();
1785 if (named_count != 0)
1789 p_new_arguments = new_arguments;
1796 this->
messageSend(messageName, new_arguments->
data(), count, named_count, r);
1800 this->
messageSend(messageName, new_arguments->
data(), count, named_count, startScope, r);
1834 this->
messageSend(messageName, arguments + 1, argCount - 1, named_argCount, r);
1838 this->
messageSend(messageName, arguments + 1, argCount - 1, named_argCount, startScope, r);
1855 RexxObject **named_arglist,
size_t named_argcount)
1862 size_t count = arguments->
size();
1871 expectedNamedArguments.
check(named_arglist, named_argcount,
true,
false);
1875 size_t named_count = 0;
1880 p_named_arguments_value = named_arguments_value;
1887 named_count = named_arguments_value->
items();
1892 if (named_count != 0)
1895 p_new_arguments = new_arguments;
1900 return startCommon(message, new_arguments->
data(), count, named_count);
1925 return startCommon(message, arguments + 1, argCount - 1, named_argCount);
1948 RexxMessage *newMessage =
new RexxMessage(
this, messageName, startScope, arguments, argCount, named_argCount);
1986 startScope = messageArray->
get(2);
1996 if (sender != target)
2023 sprintf(buffer,
"%p",
this);
2040 size_t argumentsCount,
2041 size_t named_argumentsCount)
2050 size_t argcount = 0;
2051 size_t named_argcount = 0;
2064 if (argumentsCount == 0)
2089 if (argumentsCount > 1)
2095 option = toupper(optionString->
getCharC(0));
2104 if (argumentsCount < 3)
2108 if (argumentsCount > 3)
2117 p_arglist = arglist;
2126 argumentPtr = arglist->
data();
2127 argcount = arglist->
size();
2129 if (arglist == arglistUser)
2133 p_arglist = arglist;
2140 argumentPtr = arguments + 2;
2141 argcount = argumentsCount - 2;
2154 named_argcount = named_argumentsCount;
2163 expectedNamedArguments.
check(arguments + argumentsCount, named_argumentsCount,
true,
false);
2165 argdirectory = (
RexxDirectory *)expectedNamedArguments[0].value;
2169 p_argdirectory = argdirectory;
2174 named_argcount = argdirectory->
items();
2177 if (named_argcount != 0)
2182 arglist =
new_array(2 * named_argcount);
2183 p_arglist = arglist;
2186 argumentPtr = arglist->
data();
2220 name = name->
upper();
2241 msgname = msgname->
upper();
2260 methcopy = methobj->
newScope(targetClass);
2365 ovd->
set(name, value);
2377 OrefSet(
this, objectVariables, dictionary);
2409 if (dictionary->
isScope(scope))
2421 OrefSet(
this, objectVariables, dictionary);
2461 return "unknown Class";
2482 return createClass->
getId();
2555 memcpy((
char *)cloneObj, (
char *)
this, size);
2557 cloneObj->
header = newHeader;
2561 #undef operatorMethod
2562 #define operatorMethod(name, message) RexxObject * RexxObject::name(RexxObject *operand) \
2564 ProtectedObject result; \
2566 this->messageSend(OREF_##message, &operand, 1, 0, result); \
2567 if ((RexxObject *)result == OREF_NULL) \
2569 RexxObject *self = this; \
2570 bool alternativeResult = operand->messageSend(OREF_##message##_RIGHT, &self, 1, 0, result, false); \
2571 if (alternativeResult && (RexxObject *)result != OREF_NULL) return (RexxObject *)result; \
2573 reportException(Error_No_result_object_message, OREF_##message); \
2575 return (RexxObject *)result; \
2579 #undef prefixOperatorMethod
2580 #define prefixOperatorMethod(name, message) RexxObject * RexxObject::name(RexxObject *operand) \
2582 ProtectedObject result; \
2584 this->messageSend(OREF_##message, &operand, operand == OREF_NULL ? 0 : 1, 0, result); \
2585 if ((RexxObject *)result == OREF_NULL) \
2587 if (operand != OREF_NULL) \
2589 RexxObject *self = this; \
2590 bool alternativeResult = operand->messageSend(OREF_##message##_RIGHT, &self, 1, 0, result, false); \
2591 if (alternativeResult && (RexxObject *)result != OREF_NULL) return (RexxObject *)result; \
2594 reportException(Error_No_result_object_message, OREF_##message); \
2596 return (RexxObject *)result; \
2613 operatorMethod(operator_isBackslashGreaterThan, BACKSLASH_GREATERTHAN)
2621 operatorMethod(operator_strictBackslashGreaterThan, STRICT_BACKSLASH_GREATERTHAN)
2623 operatorMethod(operator_strictBackslashLessThan, STRICT_BACKSLASH_LESSTHAN)
2625 operatorMethod(operator_strictLessOrEqual, STRICT_LESSTHAN_EQUAL)
2627 operatorMethod(operator_greaterThanLessThan, GREATERTHAN_LESSTHAN)
2642 newObject->
setBehaviour(classObject->getInstanceBehaviour());
2645 if (classObject->hasUninitDefined() || classObject->parentHasUninitDefined())
2650 return(
void *)newObject;
2654 void *RexxObject::operator
new(
size_t size,
RexxClass *classObject,
RexxObject **args,
size_t argCount,
size_t named_argCount)
2662 ((
RexxObject *)newObject)->sendMessage(OREF_INIT, args, argCount, named_argCount);
2738 return this->
copy();
2745 size_t named_argcount)
2753 expectedNamedArguments.
check(named_arglist, named_argcount,
true,
false);
2757 return this->
unknown(message, arguments, namedArguments);
2818 return(
void *)((
RexxBuffer *)C_self)->getData();
2852 return(
void *)((
RexxBuffer *)C_self)->getData();
2865 void *RexxNilObject::operator
new(
size_t size)
2881 (
PCPPM)&RexxObject::operator_plus,
2882 (
PCPPM)&RexxObject::operator_minus,
2883 (
PCPPM)&RexxObject::operator_multiply,
2884 (
PCPPM)&RexxObject::operator_divide,
2885 (
PCPPM)&RexxObject::operator_integerDivide,
2886 (
PCPPM)&RexxObject::operator_remainder,
2887 (
PCPPM)&RexxObject::operator_power,
2888 (
PCPPM)&RexxObject::operator_abuttal,
2889 (
PCPPM)&RexxObject::operator_concat,
2890 (
PCPPM)&RexxObject::operator_concatBlank,
2891 (
PCPPM)&RexxObject::operator_equal,
2892 (
PCPPM)&RexxObject::operator_notEqual,
2893 (
PCPPM)&RexxObject::operator_isGreaterThan,
2894 (
PCPPM)&RexxObject::operator_isBackslashGreaterThan,
2895 (
PCPPM)&RexxObject::operator_isLessThan,
2896 (
PCPPM)&RexxObject::operator_isBackslashLessThan,
2897 (
PCPPM)&RexxObject::operator_isGreaterOrEqual,
2898 (
PCPPM)&RexxObject::operator_isLessOrEqual,
2899 (
PCPPM)&RexxObject::operator_strictEqual,
2900 (
PCPPM)&RexxObject::operator_strictNotEqual,
2901 (
PCPPM)&RexxObject::operator_strictGreaterThan,
2902 (
PCPPM)&RexxObject::operator_strictBackslashGreaterThan,
2903 (
PCPPM)&RexxObject::operator_strictLessThan,
2904 (
PCPPM)&RexxObject::operator_strictBackslashLessThan,
2905 (
PCPPM)&RexxObject::operator_strictGreaterOrEqual,
2906 (
PCPPM)&RexxObject::operator_strictLessOrEqual,
2907 (
PCPPM)&RexxObject::operator_lessThanGreaterThan,
2908 (
PCPPM)&RexxObject::operator_greaterThanLessThan,
2909 (
PCPPM)&RexxObject::operator_and,
2910 (
PCPPM)&RexxObject::operator_or,
2911 (
PCPPM)&RexxObject::operator_xor,
2912 (
PCPPM)&RexxObject::operator_not,
void reportNomethod(RexxString *message, RexxObject *receiver)
void reportException(wholenumber_t error)
RexxMethod * lastMethod()
void missingArgument(RexxString *kind, size_t argumentPosition)
RexxArray * new_array(size_t s)
RexxInteger * new_integer(wholenumber_t v)
#define operatorMethod(name, message)
#define prefixOperatorMethod(name, message)
RexxObject *(RexxObject::* PCPPM)()
RexxString * stringArgument(RexxObject *object, RexxString *kind, size_t position)
RexxArray * REQUEST_ARRAY(RexxObject *obj)
RexxString * REQUEST_STRING(RexxObject *object)
#define isOfClassType(t, r)
RexxArray * arrayArgument(RexxObject *object, RexxString *kind, size_t position)
void requiredArgument(RexxObject *object, RexxString *kind, size_t position)
#define Error_Execution_super
#define Error_Logical_value_method
#define Error_Incorrect_method_option
#define Error_Execution_user_defined
#define Error_Incorrect_method_positive
#define Error_No_result_object_message
#define Error_Incorrect_method_nostring
#define Error_Incorrect_method_nonnegative
#define Error_Incorrect_call_list
#define Error_Incorrect_method_message
#define Error_Incorrect_method_whole
#define Error_Incorrect_method_maxarg
#define Error_Invalid_whole_number_compareto
#define Error_Incorrect_method_noarray
#define Error_Invalid_argument_string
#define memory_mark(oref)
RexxObject * new_object(size_t s)
#define flatten_reference(oref, envel)
#define CLASS_CREATE(name, id, className)
#define memory_mark_general(oref)
#define setUpFlatten(type)
RexxVariableDictionary * new_objectVariableDictionary(RexxObject *s)
RexxString * new_proxy(const char *name)
RexxString * new_string(const char *s, stringsizeB_t bl, sizeC_t cl=-1)
static RexxActivity *volatile currentActivity
void check(RexxObject **namedArglist, size_t namedArgCount, bool strict, bool extraAllowed, size_t minimumRequired=0)
virtual RexxObject * getReceiver()
SecurityManager * getEffectiveSecurityManager()
RexxActivationBase * getTopStackFrame()
bool raiseCondition(RexxString *, RexxObject *, RexxString *, RexxObject *, RexxObject *)
void put(RexxObject *eref, size_t pos)
RexxObject * get(size_t pos)
RexxMethod * methodLookup(RexxString *)
RexxTable * getMethodDictionary()
RexxObject * define(RexxString *, RexxMethod *)
void removeMethod(RexxString *)
RexxClass * getOwningClass()
RexxSupplier * getMethods(RexxObject *scope)
RexxTable * getInstanceMethodDictionary()
RexxMethod * superMethod(RexxString *, RexxObject *)
RexxObject * superScope(RexxObject *)
void addMethod(RexxString *, RexxMethod *)
bool isCompatibleWith(RexxClass *other)
size_t appendAllIndexesItemsTo(RexxArray *array, size_t from)
static RexxDirectory * fromIndexItemArray(RexxObject **arglist, size_t count)
bool available(HashLink pos)
RexxObject * value(HashLink pos)
HashLink next(HashLink pos)
RexxObject * index(HashLink pos)
virtual RexxInteger * integerValue(size_t)
virtual bool isInstanceOf(RexxClass *)
void setBehaviour(RexxBehaviour *b)
virtual RexxString * primitiveMakeString()
virtual bool unsignedNumberValue(stringsize_t &result, size_t precision)
virtual bool isEqual(RexxObject *)
void setVirtualFunctions(void *t)
bool isSubClassOrEnhanced()
virtual RexxObject * makeProxy(RexxEnvelope *)
virtual bool doubleValue(double &result)
virtual RexxString * stringValue()
virtual RexxSupplier * instanceMethods(RexxClass *)
virtual RexxString * makeString()
virtual bool numberValue(wholenumber_t &result, size_t precision)
virtual RexxArray * makeArray()
virtual RexxMethod * instanceMethod(RexxString *)
virtual void copyIntoTail(RexxCompoundTail *buffer)
virtual HashCode getHashValue()
virtual RexxObject * copy()
size_t getObjectTypeNumber()
RexxBehaviour * behaviour
virtual RexxNumberString * numberString()
virtual bool truthValue(int)
virtual bool logicalValue(logical_t &)
void removeUninitObject(RexxObject *obj)
static void * virtualFunctionTable[]
void addUninitObject(RexxObject *obj)
RexxObject * start(RexxObject *)
void run(RexxActivity *, RexxObject *, RexxString *, RexxObject **, size_t, size_t, ProtectedObject &)
static RexxMethod * newMethodObject(RexxString *, RexxObject *, RexxObject *, RexxSource *a, bool isBlock=false)
RexxMethod * newScope(RexxClass *)
static RexxObject * nilObject
virtual HashCode getHashValue()
RexxObject * isInstanceOfRexx(RexxClass *)
RexxInteger * requiredInteger(RexxString *kind, size_t, size_t)
RexxString * stringRexx()
RexxString * defaultNameRexx()
bool messageSend(RexxString *, RexxObject **, size_t, size_t, ProtectedObject &, bool processUnknown=true)
stringsize_t requiredPositive(RexxString *kind, size_t position, size_t precision=Numerics::ARGUMENT_DIGITS)
RexxMessage * start(RexxObject **, size_t, size_t)
virtual wholenumber_t compareTo(RexxObject *)
RexxString * objectName()
RexxNumberString * numberString()
RexxMessage * startCommon(RexxObject *message, RexxObject **arguments, size_t argCount, size_t named_argCount)
RexxInteger * integerValue(size_t)
RexxVariableDictionary * getObjectVariables(RexxObject *)
RexxObject * requestRexx(RexxString *)
static void decodeMessageName(RexxObject *target, RexxObject *message, RexxString *&messageName, RexxObject *&startScope)
RexxObject * sendWith(RexxObject *, RexxArray *, RexxObject **, size_t)
RexxString * concatRexx(RexxObject *)
RexxObject * unknownRexx(RexxString *, RexxArray *, RexxObject **, size_t)
bool requestUnsignedNumber(stringsize_t &, size_t)
static RexxClass * classInstance
stringsize_t requiredNonNegative(RexxString *kind, size_t position, size_t precision=Numerics::ARGUMENT_DIGITS)
RexxObject * hasMethodRexx(RexxString *)
RexxMethod * instanceMethodRexx(RexxString *)
RexxObject * unsetMethod(RexxString *)
RexxString * primitiveMakeString()
static void createInstance()
RexxObject * superScope(RexxObject *)
virtual RexxInteger * hasMethod(RexxString *msg)
RexxObject * strictEqual(RexxObject *)
void guardOn(RexxActivity *activity, RexxObject *scope)
RexxMessage * startWith(RexxObject *, RexxArray *, RexxObject **, size_t)
void processUnknown(RexxString *, RexxObject **, size_t, size_t, ProtectedObject &)
virtual bool doubleValue(double &result)
RexxInteger * requestInteger(size_t)
RexxObject * setMethod(RexxString *, RexxMethod *, RexxString *a=OREF_NULL)
RexxMethod * methodLookup(RexxString *name)
virtual RexxObject * defMethod(RexxString *, RexxMethod *, RexxString *a=OREF_NULL)
RexxString * makeString()
RexxObject * send(RexxObject **, size_t, size_t)
RexxObject * objectNameEquals(RexxObject *)
void guardOff(RexxActivity *activity, RexxObject *scope)
virtual RexxObject * unknown(RexxString *msg, RexxArray *args, RexxDirectory *named_args)
RexxArray * requestArray()
RexxString * requiredString()
void processProtectedMethod(RexxString *, RexxMethod *, RexxObject **, size_t, size_t, ProtectedObject &)
RexxString * stringValue()
RexxSupplier * instanceMethods(RexxClass *)
void flatten(RexxEnvelope *)
RexxObject * equal(RexxObject *)
void sendMessage(RexxString *, RexxArray *, RexxDirectory *, ProtectedObject &)
void liveGeneral(int reason)
RexxObject * notEqual(RexxObject *other)
bool requestNumber(wholenumber_t &, size_t)
RexxMethod * checkPrivate(RexxMethod *)
RexxInteger * identityHashRexx()
RexxDirectory * requestDirectory()
RexxMethod * instanceMethod(RexxString *)
void addObjectVariables(RexxVariableDictionary *)
RexxString * requestString()
void copyIntoTail(RexxCompoundTail *buffer)
RexxObject * makeStringRexx()
virtual bool numberValue(wholenumber_t &result, size_t precision)
RexxObject * newRexx(RexxObject **arguments, size_t argCount, size_t named_argCount)
RexxBehaviour * behaviourObject()
RexxObject * defMethods(RexxDirectory *)
bool isEqual(RexxObject *)
virtual RexxString * defaultName()
static PCPPM operatorMethods[]
RexxString * concatBlank(RexxObject *)
virtual bool unsignedNumberValue(stringsize_t &result, size_t precision)
RexxSupplier * instanceMethodsRexx(RexxClass *)
RexxString * requestStringNoNOSTRING()
RexxClass * classObject()
void setObjectVariable(RexxString *, RexxObject *, RexxObject *)
bool isInstanceOf(RexxClass *)
RexxObject * run(RexxObject **, size_t, size_t)
RexxObject * makeArrayRexx()
RexxMethod * superMethod(RexxString *, RexxObject *)
RexxObject * strictNotEqual(RexxObject *other)
RexxObject * getObjectVariable(RexxString *)
virtual bool logicalValue(logical_t &)
void copyObjectVariables(RexxObject *newObject)
wholenumber_t requiredNumber(RexxString *kind, size_t position, size_t precision=Numerics::ARGUMENT_DIGITS)
bool numberValue(wholenumber_t &result, size_t precision)
RexxString * concatRexx(RexxObject *)
RexxInteger * strictEqual(RexxObject *)
bool doubleValue(double &result)
const char * getStringData()
RexxInteger * integerValue(size_t precision)
RexxString * concatBlank(RexxObject *)
RexxNumberString * numberString()
virtual bool logicalValue(logical_t &)
RexxString * concatToCstring(const char *)
bool strCompare(const char *s)
codepoint_t getCharC(sizeC_t p)
bool unsignedNumberValue(uwholenumber_t &result, size_t precision)
void copyIntoTail(RexxCompoundTail *buffer)
RexxObject * stringGet(RexxString *key)
void setNextDictionary(RexxVariableDictionary *next)
RexxObject * realValue(RexxString *name)
bool isScope(RexxObject *otherScope)
void set(RexxString *, RexxObject *)
RexxVariableDictionary * getNextDictionary()
void reserve(RexxActivity *)
void release(RexxActivity *)
bool checkProtectedMethod(RexxObject *target, RexxString *messageName, size_t count, size_t named_count, RexxObject **arguments, ProtectedObject &result)
static int strCaselessCompare(const char *opt1, const char *opt2)