58 #include "SystemInterpreter.hpp"
348 result = std::numeric_limits<double>::signaling_NaN();
353 result = std::numeric_limits<double>::quiet_NaN();
607 const char *firstStart;
608 const char *secondStart;
636 if (alternativeOperator !=
OREF_NULL && alternativeOperatorResultPtr != NULL)
644 bool alternativeResult = other->
messageSend(alternativeOperator, args, 1, 0, result,
false);
661 return firstNum->
comp(secondNum);
675 while (firstLen > 0 && (*firstStart ==
ch_BLANK || *firstStart ==
ch_TAB))
681 while (secondLen > 0 && (*secondStart ==
ch_BLANK || *secondStart ==
ch_TAB))
687 if (firstLen >= secondLen)
693 result = memcmp(firstStart, secondStart, secondLen);
695 if ((result == 0) && (firstLen != secondLen))
698 firstStart = firstStart + secondLen;
699 while (firstLen-- > secondLen)
703 unsigned char current = *firstStart++;
716 result = memcmp(firstStart, secondStart, firstLen);
721 secondStart = secondStart + firstLen;
722 while (secondLen-- > firstLen)
726 unsigned char current = *secondStart++;
754 if (alternativeOperator !=
OREF_NULL && alternativeOperatorResultPtr != NULL)
762 bool alternativeResult = otherObj->
messageSend(alternativeOperator, args, 1, 0, result,
false);
783 if ((result == 0) && (this->
getBLength() > otherLen))
825 bool alternativeResult = right_term->
messageSend(OREF_PLUS_RIGHT, args, 1, 0, result,
false);
831 return numstr->
plus(right_term);
858 bool alternativeResult = right_term->
messageSend(OREF_SUBTRACT_RIGHT, args, 1, 0, result,
false);
864 return numstr->
minus(right_term);
884 bool alternativeResult = right_term->
messageSend(OREF_MULTIPLY_RIGHT, args, 1, 0, result,
false);
889 return numstr->
multiply(right_term);
909 bool alternativeResult = right_term->
messageSend(OREF_DIVIDE_RIGHT, args, 1, 0, result,
false);
914 return numstr->
divide(right_term);
934 bool alternativeResult = right_term->
messageSend(OREF_INTDIV_RIGHT, args, 1, 0, result,
false);
959 bool alternativeResult = right_term->
messageSend(OREF_REMAINDER_RIGHT, args, 1, 0, result,
false);
984 bool alternativeResult = right_term->
messageSend(OREF_POWER_RIGHT, args, 1, 0, result,
false);
989 return numstr->
power(right_term);
1006 return numstr->
abs();
1023 return numstr->
Sign();
1041 return numstr->
Max(arguments, argCount, named_argCount);
1059 return numstr->
Min(arguments, argCount, named_argCount);
1076 return numstr->
trunc(decimals);
1094 return numstr->
floor();
1130 return numstr->
round();
1148 return numstr->
formatRexx(Integers, Decimals, MathExp, ExpTrigger);
1201 bool alternativeResult = other->
messageSend(OREF_STRICT_EQUAL_RIGHT, args, 1, 0, result,
false);
1228 bool alternativeResult = other->
messageSend(OREF_STRICT_BACKSLASH_EQUAL_RIGHT, args, 1, 0, result,
false);
1249 if (alternativeResult !=
OREF_NULL)
return alternativeResult;
1265 wholenumber_t result = this->
comp(other, OREF_BACKSLASH_EQUAL_RIGHT, &alternativeResult);
1266 if (alternativeResult !=
OREF_NULL)
return alternativeResult;
1282 wholenumber_t result = this->
comp(other, OREF_GREATERTHAN_RIGHT, &alternativeResult);
1283 if (alternativeResult !=
OREF_NULL)
return alternativeResult;
1299 wholenumber_t result = this->
comp(other, OREF_LESSTHAN_RIGHT, &alternativeResult);
1300 if (alternativeResult !=
OREF_NULL)
return alternativeResult;
1316 wholenumber_t result = this->
comp(other, OREF_GREATERTHAN_EQUAL_RIGHT, &alternativeResult);
1317 if (alternativeResult !=
OREF_NULL)
return alternativeResult;
1333 wholenumber_t result = this->
comp(other, OREF_LESSTHAN_EQUAL_RIGHT, &alternativeResult);
1334 if (alternativeResult !=
OREF_NULL)
return alternativeResult;
1351 if (alternativeResult !=
OREF_NULL)
return alternativeResult;
1368 if (alternativeResult !=
OREF_NULL)
return alternativeResult;
1385 if (alternativeResult !=
OREF_NULL)
return alternativeResult;
1402 if (alternativeResult !=
OREF_NULL)
return alternativeResult;
1473 bool alternativeResult = otherObj->
messageSend(OREF_CONCATENATE_RIGHT, args, 1, 0, result,
false);
1525 blen2 = strlen(other);
1532 memcpy(result->
getWritableData() + blen2, this->getStringData(), blen1);
1551 blen2 = strlen(other);
1588 bool alternativeResult = otherObj->
messageSend(OREF_BLANK_RIGHT, args, 1, 0, result,
false);
1685 if (testString->
getCharC(0) ==
'0')
1691 else if (testString->
getCharC(0) ==
'1')
1711 const char *i3 = i2;
1716 if ( (*i1++ | *i2-- | *i3++ | *i4--) & 0x80 )
return false;
1718 while (i1 <= i2 || i3 <= i4);
1739 const char *endData;
1744 while (data < endData)
1746 if (*data != toupper(*data))
1772 const char *endData;
1778 while (data < endData)
1780 *outdata = toupper(*data);
1799 const unsigned char *Current;
1851 bool needTranslation;
1854 needTranslation =
false;
1858 if (*data != tolower(*data))
1860 needTranslation =
true;
1865 if (needTranslation)
1875 *outdata = tolower(*data);
1913 if (rangeLength == 0)
1918 return lower(startPos, rangeLength);
1947 if (rangeLength == 0)
1952 return upper(startPos, rangeLength);
1976 for (
size_t i = 0; i < _length; i++)
1978 *data = tolower(*data);
2006 for (
size_t i = 0; i < _length; i++)
2008 *data = toupper(*data);
2119 bool alternativeResult = other->
messageSend(OREF_AND_RIGHT, args, 1, 0, result,
false);
2147 bool alternativeResult = other->
messageSend(OREF_OR_RIGHT, args, 1, 0, result,
false);
2173 bool alternativeResult = other->
messageSend(OREF_XOR_RIGHT, args, 1, 0, result,
false);
2223 const char *digitPtr;
2230 for (; digitsLeft != 0 && (*digitPtr ==
ch_BLANK || *digitPtr ==
ch_TAB); ++digitPtr, --digitsLeft) ;
2232 if (digitsLeft != 0)
2238 for (++digitPtr, --digitsLeft;
2239 digitsLeft != 0 && (*digitPtr ==
ch_BLANK || *digitPtr ==
ch_TAB);
2240 ++digitPtr, --digitsLeft) ;
2242 if (digitsLeft == 0)
2250 for (; digitsLeft != 0 && *digitPtr >=
ch_ZERO && *digitPtr <=
ch_NINE;
2251 ++digitPtr, --digitsLeft) ;
2254 if ( digitsLeft != 0 && *digitPtr ==
ch_PERIOD)
2258 for (; digitsLeft != 0 && *digitPtr ==
ch_ZERO; ++digitPtr, --digitsLeft) ;
2262 for (; digitsLeft != 0 && (*digitPtr ==
ch_BLANK || *digitPtr ==
ch_TAB); ++digitPtr, --digitsLeft) ;
2266 if (digitsLeft == 0)
2438 const char *indata = string;
2439 const char *endData = indata +
blength;
2440 while (indata < endData)
2442 *outdata = toupper(*indata);
2490 sprintf(buffer,
"%.*g", (
int)precision, number);
2491 size_t len = strlen(buffer);
2493 if (buffer[len - 1] ==
'.')
2538 if (((
RexxClass *)
this)->hasUninitDefined())
2540 string->hasUninit();
2543 string->sendMessage(OREF_INIT, init_args, argCount, named_argCount);
2602 void *RexxText::operator
new(
size_t size)
void reportException(wholenumber_t error)
RexxInteger * new_integer(wholenumber_t v)
RexxNumberString * new_numberstring(const char *s, stringsize_t l)
RexxNumberString * new_numberstringFromDouble(double n)
RexxObject *(RexxObject::* PCPPM)()
RexxString * stringArgument(RexxObject *object, RexxString *kind, size_t position)
RexxString * REQUEST_STRING(RexxObject *object)
bool isPolymorphicString(RexxObject *o)
bool isString(RexxObject *o)
size_t optionalLengthArgument(RexxObject *o, size_t d, size_t p)
size_t optionalPositionArgument(RexxObject *o, size_t d, size_t p)
#define TheNumberStringClass
void requiredArgument(RexxObject *object, RexxString *kind, size_t position)
#define Error_Logical_value_method
#define Error_No_result_object_message
#define Error_Incorrect_method_nostring
#define Error_Incorrect_method_string_nonumber
#define Error_Conversion_operator
#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)
RexxString * new_string(const char *s, stringsizeB_t bl, sizeC_t cl=-1)
RexxString * raw_string(stringsizeB_t bl, stringsizeC_t cl=-1)
static wholenumber_t minVal(wholenumber_t n1, wholenumber_t n2)
void traceIntermediate(RexxObject *v, int p)
static void processNewArgs(RexxObject **, size_t, RexxObject ***, size_t *, size_t, RexxObject **, RexxObject **)
void append(const char *newData, size_t stringLen)
void push(RexxObject *value)
void setString(RexxString *string)
RexxString * getStringrep()
RexxObject * getValue(RexxActivation *)
void setBehaviour(RexxBehaviour *b)
void setHasNoReferences()
wholenumber_t comp(RexxObject *, RexxString *alternativeOperator=OREF_NULL, RexxInteger **alternativeOperatorResultPtr=NULL)
RexxNumberString * multiply(RexxObject *)
RexxNumberString * minus(RexxObject *)
RexxNumberString * Max(RexxObject **, size_t, size_t)
bool unsignedNumberValue(uwholenumber_t &result, size_t precision)
RexxString * stringValue()
RexxString * formatRexx(RexxObject *, RexxObject *, RexxObject *, RexxObject *)
RexxInteger * integerValue(size_t)
RexxNumberString * Min(RexxObject **, size_t, size_t)
void setString(RexxString *)
RexxNumberString * integerDivide(RexxObject *)
bool numberValue(wholenumber_t &result, size_t precision)
RexxObject * trunc(RexxObject *)
RexxNumberString * power(RexxObject *)
RexxNumberString * remainder(RexxObject *)
RexxNumberString * plus(RexxObject *)
RexxNumberString * divide(RexxObject *)
bool doubleValue(double &result)
bool messageSend(RexxString *, RexxObject **, size_t, size_t, ProtectedObject &, bool processUnknown=true)
virtual wholenumber_t compareTo(RexxObject *)
RexxNumberString * numberString()
RexxString * stringValue()
void sendMessage(RexxString *, RexxArray *, RexxDirectory *, ProtectedObject &)
RexxString * requestString()
RexxClass * classObject()
RexxObject * makeArrayRexx()
RexxString * stringValue()
bool numberValue(wholenumber_t &result, size_t precision)
RexxInteger * isLessOrEqual(RexxObject *)
RexxInteger * isLessThan(RexxObject *)
RexxString * concatRexx(RexxObject *)
static void createInstance()
RexxInteger * strictEqual(RexxObject *)
static RexxString * newString(const char *, sizeB_t bl, sizeC_t cl=-1)
RexxInteger * caselessEquals(RexxString *other)
static RexxString * newProxy(const char *)
RexxString * extractB(sizeB_t offset, sizeB_t sublength)
RexxObject * trunc(RexxInteger *decimals)
RexxObject * xorOp(RexxObject *)
RexxObject * operatorNot(RexxObject *)
RexxObject * Min(RexxObject **args, size_t argCount, size_t named_argCount)
bool primitiveCaselessIsEqual(RexxObject *)
RexxInteger * strictGreaterThan(RexxObject *)
RexxObject * evaluate(RexxActivation *, RexxExpressionStack *)
RexxString * upperRexx(RexxInteger *, RexxInteger *)
HashCode getObjectHashCode()
RexxInteger * notEqual(RexxObject *)
RexxInteger * strictLessOrEqual(RexxObject *)
RexxNumberString * createNumberString()
RexxObject * lengthRexx()
RexxNumberString * fastNumberString()
RexxObject * format(RexxObject *Integers, RexxObject *Decimals, RexxObject *MathExp, RexxObject *ExpTrigger)
bool doubleValue(double &result)
void liveGeneral(int reason)
void setBLength(sizeB_t l)
RexxString * makeString()
const char * getStringData()
RexxObject * integerDivide(RexxObject *right)
void setNumberString(RexxObject *)
RexxObject * remainder(RexxObject *right)
RexxObject * Max(RexxObject **args, size_t argCount, size_t named_argCount)
RexxInteger * integerValue(size_t precision)
RexxString * concatBlank(RexxObject *)
RexxNumberString * numberString()
void setCLength(sizeC_t l)
RexxInteger * compareToRexx(RexxString *other, RexxInteger *start_, RexxInteger *len_)
RexxObject * getRealValue(RexxActivation *)
char putCharB(sizeB_t p, char c)
bool primitiveIsEqual(RexxObject *)
RexxObject * plus(RexxObject *right)
RexxInteger * strictLessThan(RexxObject *)
RexxInteger * strictGreaterOrEqual(RexxObject *)
void flatten(RexxEnvelope *envelope)
RexxInteger * equal(RexxObject *)
RexxObject * multiply(RexxObject *right)
RexxString * concatWithCstring(const char *)
static RexxClass * classInstance
virtual bool logicalValue(logical_t &)
RexxObject * andOp(RexxObject *)
bool isEqual(RexxObject *)
wholenumber_t comp(RexxObject *, RexxString *alternativeOperator=OREF_NULL, RexxInteger **alternativeOperatorResultPtr=NULL)
virtual HashCode getHashValue()
RexxString * concat(RexxString *)
RexxString * concatWith(RexxString *, char)
static RexxString * newUpperString(const char *, stringsizeB_t bl, stringsizeC_t cl=-1)
RexxObject * getValue(RexxActivation *)
RexxString * stringTrace()
RexxString * concatToCstring(const char *)
wholenumber_t compareTo(RexxObject *)
RexxNumberString * NumberString
bool strCompare(const char *s)
void copyToRxstring(RXSTRING &r)
void put(sizeB_t s, const void *b, sizeB_t l)
codepoint_t getCharC(sizeC_t p)
sizeB_t copyData(sizeB_t, char *, sizeB_t)
RexxInteger * isASCIIRexx()
RexxInteger * isGreaterOrEqual(RexxObject *)
RexxObject * orOp(RexxObject *)
RexxString * newRexx(RexxObject **, size_t, size_t)
RexxObject * divide(RexxObject *right)
static RexxString * rawString(sizeB_t bl, sizeC_t cl=-1)
RexxObject * unflatten(RexxEnvelope *)
RexxInteger * equals(RexxString *other)
RexxInteger * isGreaterThan(RexxObject *)
wholenumber_t strictComp(RexxObject *, RexxString *alternativeOperator=NULL, RexxInteger **alternativeOperatorResultPtr=NULL)
RexxObject * power(RexxObject *right)
RexxString * lowerRexx(RexxInteger *, RexxInteger *)
bool unsignedNumberValue(uwholenumber_t &result, size_t precision)
static PCPPM operatorMethods[]
RexxString * primitiveMakeString()
RexxInteger * strictNotEqual(RexxObject *)
RexxObject * minus(RexxObject *right)
void copyIntoTail(RexxCompoundTail *buffer)
void liveGeneral(int reason)
static RexxClass * classInstance
void flatten(RexxEnvelope *)
static void createInstance()
virtual RexxObject * unflatten(RexxEnvelope *)
static int caselessCompare(const char *, const char *, sizeB_t)
static RexxArray * makearray(const char *start, sizeB_t length, RexxString *separator)
static void * allocateResultMemory(sizeB_t)
stringsize_t stringsizeC_t
stringsize_t stringsizeB_t