ooRexx
4.2.0-source
About: ooRexx (Open Object Rexx) is a free implementation of Object Rexx. Object Rexx is an enhancement of the classic Rexx interpreter; a full-featured programming language with a human-oriented syntax. Fossies Dox: ooRexx-4.2.0-source.tar.gz ("inofficial" and yet experimental doxygen-generated source code documentation) 
|
Go to the documentation of this file. 69 #define DEFAULT_BUFFER_LENGTH 256 89 string = OREF_NULLSTRING;
94 string = OREF_NULLSTRING;
102 defaultSize = bufferLength;
108 bufferLength =
string->getLength();
117 newBuffer->
sendMessage(OREF_INIT, args, argc > 2 ? argc - 2 : 0);
163 void *RexxMutableBuffer::operator
new(
size_t size)
178 void *RexxMutableBuffer::operator
new(
size_t size,
RexxClass *bufferClass)
181 newObj->
setBehaviour(bufferClass->getInstanceBehaviour());
241 size_t resultLength = this->
dataLength + addedLength;
277 if (newLength > capacity)
279 newLength = capacity;
286 if (newLength > oldLength)
288 this->
setData(oldLength,
'\0', newLength - oldLength);
356 size_t padLength = insertLength - copyLength;
364 if (insertLength == 0)
434 setData(begin + string->
getLength(), padChar, replaceLength -
string->getLength());
469 size_t newLength =
string->getLength();
494 finalLength = begin - replaceLength + newLength;
498 finalLength =
dataLength - replaceLength + newLength;
518 if (replaceLength != newLength && begin + replaceLength <
dataLength)
521 adjustGap(begin, replaceLength, newLength);
801 size_t needleLength = needle->
getLength();
802 size_t newLength = newNeedle->
getLength();
804 size_t resultLength = this->
getLength() - (matches * needleLength) + (matches * newLength);
811 if (needleLength == newLength)
816 for (
size_t i = 0; i < matches; i++)
820 size_t matchPos =
StringUtil::pos(source, sourceLength, needle, _start, sourceLength);
823 _start = matchPos + newLength - 1;
827 else if (needleLength > newLength)
830 size_t copyOffset = 0;
837 for (
size_t i = 0; i < matches; i++)
840 size_t matchPos =
StringUtil::pos(source, sourceLength, needle, _start, sourceLength);
841 size_t copyLength = (matchPos - 1) - _start;
845 copyData(copyOffset, source + _start, copyLength);
846 copyOffset += copyLength;
851 copyData(copyOffset, newPtr, newLength);
852 copyOffset += newLength;
854 _start = matchPos + needleLength - 1;
857 if (_start < sourceLength)
859 copyData(copyOffset, source + _start, sourceLength - _start);
866 size_t growth = (newLength - needleLength) * matches;
869 size_t copyOffset = 0;
876 openGap(0, growth, sourceLength);
879 for (
size_t i = 0; i < matches; i++)
882 size_t matchPos =
StringUtil::pos(source, sourceLength, needle, _start, sourceLength);
883 size_t copyLength = (matchPos - 1) - _start;
887 copyData(copyOffset, source + _start, copyLength);
888 copyOffset += copyLength;
893 copyData(copyOffset, newPtr, newLength);
894 copyOffset += newLength;
896 _start = matchPos + needleLength - 1;
899 if (_start < sourceLength)
901 copyData(copyOffset, source + _start, sourceLength - _start);
939 size_t needleLength = needle->
getLength();
940 size_t newLength = newNeedle->
getLength();
942 size_t resultLength = this->
getLength() - (matches * needleLength) + (matches * newLength);
949 if (needleLength == newLength)
954 for (
size_t i = 0; i < matches; i++)
961 _start = matchPos + newLength - 1;
965 else if (needleLength > newLength)
968 size_t copyOffset = 0;
975 for (
size_t i = 0; i < matches; i++)
979 size_t copyLength = (matchPos - 1) - _start;
983 copyData(copyOffset, source + _start, copyLength);
984 copyOffset += copyLength;
989 copyData(copyOffset, newPtr, newLength);
990 copyOffset += newLength;
992 _start = matchPos + needleLength - 1;
995 if (_start < sourceLength)
997 copyData(copyOffset, source + _start, sourceLength - _start);
1004 size_t growth = (newLength - needleLength) * matches;
1007 size_t copyOffset = 0;
1014 openGap(0, growth, sourceLength);
1017 for (
size_t i = 0; i < matches; i++)
1021 size_t copyLength = (matchPos - 1) - _start;
1023 if (copyLength != 0)
1025 copyData(copyOffset, source + _start, copyLength);
1026 copyOffset += copyLength;
1031 copyData(copyOffset, newPtr, newLength);
1032 copyOffset += newLength;
1034 _start = matchPos + needleLength - 1;
1037 if (_start < sourceLength)
1039 copyData(copyOffset, source + _start, sourceLength - _start);
1072 if (rangeLength == 0)
1077 char *bufferData =
getData() + startPos;
1079 for (
size_t i = 0; i < rangeLength; i++)
1081 *bufferData = tolower(*bufferData);
1112 if (rangeLength == 0)
1117 char *bufferData =
getData() + startPos;
1119 for (
size_t i = 0; i < rangeLength; i++)
1121 *bufferData = toupper(*bufferData);
1144 return this->
upper(_start, _range);
1148 size_t outTableLength = tableo->
getLength();
1151 size_t inTableLength = tablei->
getLength();
1160 if (startPos >
getLength() || range == 0)
1166 char *scanPtr =
getData() + startPos - 1;
1167 size_t scanLength = range;
1169 while (scanLength--)
1174 if (tablei != OREF_NULLSTRING)
1181 position = ((size_t)ch) & 0xff;
1183 if (position != (
size_t)(-1))
1185 if (position < outTableLength)
1188 *scanPtr = *(outTable + position);
1235 if ((offset + len - 1) > other->
getLength())
1278 if ((offset + len - 1) > other->
getLength())
1362 char _matchChar =
getChar(position - 1);
1367 if (_matchChar == matchSet->
getChar(i))
1398 char _matchChar =
getChar(position - 1);
1399 _matchChar = toupper(_matchChar);
1405 if (_matchChar == toupper(matchSet->
getChar(i)))
1571 const char *nextSite = NULL;
1574 while (--_wordPos > 0 && _wordLength != 0)
1586 while (--count > 0 && _wordLength != 0)
1597 size_t gapSize =
dataLength - (deletePosition + length);
1599 closeGap(deletePosition, gapSize, length);
1627 const char padC =
' ';
1628 const size_t padL = 1;
1645 size_t writePos = 0;
1647 const char *nextSite = NULL;
1653 while (_wordLength != 0)
1656 copyData(writePos, _word, _wordLength);
1657 writePos += _wordLength;
1661 if (_wordLength == 0)
1668 setData(writePos, padChar, padLength);
1669 writePos += padLength;
1674 setData(writePos, padC, padL);
1681 if ( padLength > 1 )
1683 size_t growth = count * (padLength-1);
1693 setData(writePos, padC, padL);
1702 const char *nextSite = NULL;
1707 while (_wordLength != 0)
1710 copyData(writePos, _word, _wordLength);
1711 writePos += _wordLength;
1715 if (_wordLength != 0)
1717 setData(writePos, padChar, padLength);
1718 writePos += padLength;
void sendMessage(RexxString *, RexxArray *, ProtectedObject &)
RexxInteger * posRexx(RexxString *needle, RexxInteger *_start, RexxInteger *_range)
RexxMutableBuffer * upper(RexxInteger *_start, RexxInteger *_length)
RexxInteger * caselessWordPos(RexxString *, RexxInteger *)
RexxMutableBuffer * caselessChangeStr(RexxString *needle, RexxString *newNeedle, RexxInteger *countArg)
char * setCapacity(size_t newLength)
static RexxInteger * caselessWordPos(const char *data, size_t length, RexxString *phrase, RexxInteger *pstart)
static RexxClass * classInstance
RexxMutableBuffer * append(RexxObject *)
static int caselessCompare(const char *, const char *, size_t)
RexxInteger * new_integer(wholenumber_t v)
RexxObject * lengthRexx()
#define memory_mark_general(oref)
size_t optionalNonNegative(RexxObject *o, size_t d, size_t p)
RexxInteger * matchChar(RexxInteger *position_, RexxString *matchSet)
size_t optionalLengthArgument(RexxObject *o, size_t d, size_t p)
RexxMutableBuffer * overlay(RexxObject *, RexxObject *, RexxObject *, RexxObject *)
static RexxInteger * posRexx(const char *stringData, size_t length, RexxString *needle, RexxInteger *pstart, RexxInteger *range)
bool primitiveMatch(stringsize_t start, RexxString *other, stringsize_t offset, stringsize_t len)
void flatten(RexxEnvelope *envelope)
static RexxInteger * wordIndex(const char *data, size_t length, RexxInteger *position)
static void createInstance()
RexxMutableBuffer * replaceAt(RexxObject *str, RexxObject *pos, RexxObject *len, RexxObject *pad)
RexxMutableBuffer * lower(RexxInteger *_start, RexxInteger *_length)
RexxString * substr(RexxInteger *startPosition, RexxInteger *len, RexxString *pad)
RexxString * subchar(RexxInteger *startPosition)
bool primitiveCaselessMatch(stringsize_t start, RexxString *other, stringsize_t offset, stringsize_t len)
RexxInteger * match(RexxInteger *start_, RexxString *other, RexxInteger *offset_, RexxInteger *len_)
size_t setDataLength(size_t l)
static void skipBlanks(const char **String, size_t *StringLength)
static size_t wordCount(const char *String, size_t StringLength)
static RexxArray * makearray(const char *start, size_t length, RexxString *separator)
void reportException(wholenumber_t error)
RexxMutableBuffer * delWord(RexxInteger *position, RexxInteger *plength)
char getChar(size_t offset)
static const wholenumber_t MAX_WHOLENUMBER
RexxMutableBuffer * insert(RexxObject *, RexxObject *, RexxObject *, RexxObject *)
RexxMutableBuffer * changeStr(RexxString *needle, RexxString *newNeedle, RexxInteger *countArg)
void copyData(size_t offset, const char *string, size_t l)
static RexxString * word(const char *data, size_t length, RexxInteger *position)
const char * getStringData()
RexxInteger * wordPos(RexxString *, RexxInteger *)
void closeGap(size_t offset, size_t _size, size_t tailSize)
void setData(size_t offset, char character, size_t l)
static RexxString * subWord(const char *data, size_t length, RexxInteger *position, RexxInteger *plength)
static size_t pos(const char *stringData, size_t haystack_length, RexxString *needle, size_t _start, size_t _range)
RexxObject * makeArrayRexx()
static RexxInteger * wordLength(const char *data, size_t length, RexxInteger *position)
RexxInteger * caselessCountStrRexx(RexxString *needle)
static RexxInteger * wordPos(const char *data, size_t length, RexxString *phrase, RexxInteger *pstart)
static RexxString * subchar(const char *stringData, size_t stringLength, RexxInteger *positionArg)
RexxMutableBuffer * space(RexxInteger *space_count, RexxString *pad)
size_t optionalPositionArgument(RexxObject *o, size_t d, size_t p)
stringsize_t lengthArgument(RexxObject *argument, size_t position)
RexxString * new_string(const char *s, stringsize_t l)
RexxMutableBuffer * mydelete(RexxObject *, RexxObject *)
RexxInteger * caselessLastPos(RexxString *needle, RexxInteger *_start, RexxInteger *_range)
RexxString * optionalStringArgument(RexxObject *o, RexxString *d, size_t p)
RexxString * subWord(RexxInteger *, RexxInteger *)
#define Error_Incorrect_method_position
RexxInteger * caselessMatchChar(RexxInteger *position_, RexxString *matchSet)
void setBehaviour(RexxBehaviour *b)
#define flatten_reference(oref, envel)
static RexxString * substr(const char *, size_t, RexxInteger *, RexxInteger *, RexxString *)
static RexxInteger * verify(const char *data, size_t stringLen, RexxString *ref, RexxString *option, RexxInteger *_start, RexxInteger *range)
void liveGeneral(int reason)
void ensureCapacity(size_t addedLength)
char optionalPadArgument(RexxObject *o, char d, size_t p)
static RexxInteger * lastPosRexx(const char *stringData, size_t haystackLen, RexxString *needle, RexxInteger *_start, RexxInteger *_range)
size_t optionalPositive(RexxObject *o, size_t d, size_t p)
#define CLASS_CREATE(name, id, className)
RexxObject * setBufferSize(RexxInteger *)
static wholenumber_t minVal(wholenumber_t n1, wholenumber_t n2)
RexxInteger * caselessPos(RexxString *needle, RexxInteger *_start, RexxInteger *_range)
RexxString * makeString()
#define memory_mark(oref)
RexxMutableBuffer * newRexx(RexxObject **, size_t)
RexxInteger * countStrRexx(RexxString *needle)
RexxMutableBuffer * translate(RexxString *tableo, RexxString *tablei, RexxString *pad, RexxInteger *, RexxInteger *)
static size_t caselessLastPos(const char *stringData, size_t hastackLen, RexxString *needle, size_t _start, size_t range)
static size_t nextWord(const char **String, size_t *StringLength, const char **NextString)
RexxInteger * wordIndex(RexxInteger *)
static RexxArray * subWords(const char *data, size_t length, RexxInteger *position, RexxInteger *plength)
RexxArray * subWords(RexxInteger *, RexxInteger *)
RexxString * word(RexxInteger *)
RexxInteger * lastPos(RexxString *needle, RexxInteger *_start, RexxInteger *_range)
RexxBuffer * new_buffer(size_t s)
void openGap(size_t offset, size_t _size, size_t tailSize)
static size_t caselessCountStr(const char *hayStack, size_t hayStackLength, RexxString *needle)
#define setUpFlatten(type)
RexxInteger * caselessMatch(RexxInteger *start_, RexxString *other, RexxInteger *offset_, RexxInteger *len_)
void adjustGap(size_t offset, size_t _size, size_t _newSize)
stringsize_t positionArgument(RexxObject *argument, size_t position)
#define Error_Incorrect_method_length
void copyData(size_t offset, const char *string, size_t l)
const char * getStringData()
RexxString * stringArgument(RexxObject *object, size_t position)
static size_t caselessPos(const char *stringData, size_t haystack_length, RexxString *needle, size_t _start, size_t _range)
RexxString * primitiveMakeString()
static size_t countStr(const char *hayStack, size_t hayStackLength, RexxString *needle)
RexxObject * new_object(size_t s)
static size_t memPos(const char *string, size_t length, char target)
RexxInteger * verify(RexxString *, RexxString *, RexxInteger *, RexxInteger *)
RexxInteger * wordLength(RexxInteger *)
#define DEFAULT_BUFFER_LENGTH