You can subscribe to this list here.
2006 |
Jan
|
Feb
|
Mar
|
Apr
|
May
|
Jun
|
Jul
|
Aug
|
Sep
(4) |
Oct
(20) |
Nov
(42) |
Dec
(32) |
---|---|---|---|---|---|---|---|---|---|---|---|---|
2007 |
Jan
(10) |
Feb
(42) |
Mar
(53) |
Apr
(121) |
May
(98) |
Jun
(110) |
Jul
(110) |
Aug
(88) |
Sep
(123) |
Oct
(321) |
Nov
(172) |
Dec
(607) |
2008 |
Jan
(376) |
Feb
(52) |
Mar
(26) |
Apr
(60) |
May
(42) |
Jun
(120) |
Jul
(181) |
Aug
(318) |
Sep
(265) |
Oct
(225) |
Nov
(92) |
Dec
(103) |
2009 |
Jan
(202) |
Feb
(191) |
Mar
(102) |
Apr
(235) |
May
(169) |
Jun
(122) |
Jul
(178) |
Aug
(87) |
Sep
(102) |
Oct
(69) |
Nov
(71) |
Dec
(101) |
2010 |
Jan
(55) |
Feb
(139) |
Mar
(99) |
Apr
(101) |
May
(112) |
Jun
(65) |
Jul
(31) |
Aug
(50) |
Sep
(94) |
Oct
(101) |
Nov
(95) |
Dec
(103) |
2011 |
Jan
(139) |
Feb
(136) |
Mar
(80) |
Apr
(59) |
May
(34) |
Jun
(37) |
Jul
(66) |
Aug
(51) |
Sep
(29) |
Oct
(100) |
Nov
(49) |
Dec
(92) |
2012 |
Jan
(53) |
Feb
(147) |
Mar
(113) |
Apr
(60) |
May
(39) |
Jun
(164) |
Jul
(143) |
Aug
(84) |
Sep
(127) |
Oct
(91) |
Nov
(97) |
Dec
(103) |
2013 |
Jan
(162) |
Feb
(139) |
Mar
(106) |
Apr
(23) |
May
(80) |
Jun
(73) |
Jul
(39) |
Aug
(27) |
Sep
(38) |
Oct
(54) |
Nov
(95) |
Dec
(195) |
2014 |
Jan
(113) |
Feb
(46) |
Mar
(22) |
Apr
(18) |
May
(136) |
Jun
(145) |
Jul
(86) |
Aug
(70) |
Sep
(169) |
Oct
(216) |
Nov
(58) |
Dec
(19) |
2015 |
Jan
|
Feb
(5) |
Mar
(7) |
Apr
(15) |
May
(22) |
Jun
(18) |
Jul
(4) |
Aug
(2) |
Sep
(3) |
Oct
(21) |
Nov
(24) |
Dec
(1) |
2016 |
Jan
|
Feb
(7) |
Mar
(1) |
Apr
(19) |
May
(10) |
Jun
(31) |
Jul
(24) |
Aug
(41) |
Sep
(12) |
Oct
(19) |
Nov
|
Dec
|
2017 |
Jan
(12) |
Feb
(15) |
Mar
(12) |
Apr
(8) |
May
(25) |
Jun
(8) |
Jul
(18) |
Aug
(4) |
Sep
(11) |
Oct
(25) |
Nov
(7) |
Dec
(11) |
2018 |
Jan
(2) |
Feb
(13) |
Mar
(28) |
Apr
(53) |
May
(5) |
Jun
(6) |
Jul
(13) |
Aug
(23) |
Sep
(10) |
Oct
(14) |
Nov
(33) |
Dec
(116) |
2019 |
Jan
(46) |
Feb
(112) |
Mar
(38) |
Apr
(23) |
May
(10) |
Jun
(2) |
Jul
(18) |
Aug
(4) |
Sep
(11) |
Oct
(15) |
Nov
(15) |
Dec
(17) |
2020 |
Jan
(6) |
Feb
(12) |
Mar
(41) |
Apr
(36) |
May
(7) |
Jun
(18) |
Jul
(5) |
Aug
(6) |
Sep
(6) |
Oct
(8) |
Nov
(13) |
Dec
(9) |
2021 |
Jan
(1) |
Feb
(42) |
Mar
(37) |
Apr
(16) |
May
(25) |
Jun
(4) |
Jul
(14) |
Aug
(5) |
Sep
|
Oct
(15) |
Nov
(29) |
Dec
(11) |
2022 |
Jan
(10) |
Feb
(1) |
Mar
(8) |
Apr
(16) |
May
(46) |
Jun
(37) |
Jul
(36) |
Aug
(10) |
Sep
(15) |
Oct
(6) |
Nov
(6) |
Dec
(68) |
2023 |
Jan
(27) |
Feb
(18) |
Mar
(7) |
Apr
(21) |
May
(12) |
Jun
(8) |
Jul
(16) |
Aug
(16) |
Sep
(2) |
Oct
(8) |
Nov
(3) |
Dec
(17) |
2024 |
Jan
(27) |
Feb
(9) |
Mar
(25) |
Apr
(21) |
May
(1) |
Jun
(8) |
Jul
(12) |
Aug
(30) |
Sep
(27) |
Oct
|
Nov
|
Dec
|
From: <bi...@us...> - 2008-08-19 03:42:30
|
Revision: 3014 http://oorexx.svn.sourceforge.net/oorexx/?rev=3014&view=rev Author: bigrixx Date: 2008-08-19 03:42:38 +0000 (Tue, 19 Aug 2008) Log Message: ----------- [ 1739607 ] Please add string (Last-)Pos length parameter Modified Paths: -------------- main/trunk/interpreter/classes/MutableBufferClass.cpp main/trunk/interpreter/classes/MutableBufferClass.hpp main/trunk/interpreter/classes/StringClass.hpp main/trunk/interpreter/classes/StringClassMisc.cpp main/trunk/interpreter/classes/StringUtil.cpp main/trunk/interpreter/classes/StringUtil.hpp main/trunk/interpreter/expression/BuiltinFunctions.cpp main/trunk/interpreter/memory/Setup.cpp Modified: main/trunk/interpreter/classes/MutableBufferClass.cpp =================================================================== --- main/trunk/interpreter/classes/MutableBufferClass.cpp 2008-08-19 03:19:42 UTC (rev 3013) +++ main/trunk/interpreter/classes/MutableBufferClass.cpp 2008-08-19 03:42:38 UTC (rev 3014) @@ -561,9 +561,9 @@ * @return The index of the located string. Returns 0 if no matches * are found. */ -RexxInteger *RexxMutableBuffer::posRexx(RexxString *needle, RexxInteger *pstart) +RexxInteger *RexxMutableBuffer::posRexx(RexxString *needle, RexxInteger *pstart, RexxInteger *range) { - return StringUtil::posRexx(getStringData(), getLength(), needle, pstart); + return StringUtil::posRexx(getStringData(), getLength(), needle, pstart, range); } @@ -577,9 +577,9 @@ * @return The index of the located string. Returns 0 if no matches * are found. */ -RexxInteger *RexxMutableBuffer::lastPos(RexxString *needle, RexxInteger *_start) +RexxInteger *RexxMutableBuffer::lastPos(RexxString *needle, RexxInteger *_start, RexxInteger *_range) { - return StringUtil::lastPosRexx(getStringData(), getLength(), needle, _start); + return StringUtil::lastPosRexx(getStringData(), getLength(), needle, _start, _range); } @@ -592,15 +592,16 @@ * @return The index of the located string. Returns 0 if no matches * are found. */ -RexxInteger *RexxMutableBuffer::caselessPos(RexxString *needle, RexxInteger *pstart) +RexxInteger *RexxMutableBuffer::caselessPos(RexxString *needle, RexxInteger *pstart, RexxInteger *range) { /* force needle to a string */ needle = stringArgument(needle, ARG_ONE); /* get the starting position */ size_t _start = optionalPositionArgument(pstart, 1, ARG_TWO); + size_t _range = optionalLengthArgument(range, getLength() - _start + 1, ARG_THREE); /* pass on to the primitive function */ /* and return as an integer object */ - return new_integer(StringUtil::caselessPos(getStringData(), getLength(), needle , _start - 1)); + return new_integer(StringUtil::caselessPos(getStringData(), getLength(), needle , _start - 1, _range)); } @@ -614,15 +615,16 @@ * @return The index of the located string. Returns 0 if no matches * are found. */ -RexxInteger *RexxMutableBuffer::caselessLastPos(RexxString *needle, RexxInteger *pstart) +RexxInteger *RexxMutableBuffer::caselessLastPos(RexxString *needle, RexxInteger *pstart, RexxInteger *range) { /* force needle to a string */ needle = stringArgument(needle, ARG_ONE); /* get the starting position */ size_t _start = optionalPositionArgument(pstart, getLength(), ARG_TWO); + size_t _range = optionalPositionArgument(range, getLength(), ARG_THREE); /* pass on to the primitive function */ /* and return as an integer object */ - return new_integer(StringUtil::caselessLastPos(getStringData(), getLength(), needle , _start - 1)); + return new_integer(StringUtil::caselessLastPos(getStringData(), getLength(), needle , _start - 1, _range)); } @@ -724,7 +726,7 @@ { // search for the next occurrence...which should be there because we // already know the count - size_t matchPos = StringUtil::pos(source, sourceLength, needle, _start); + size_t matchPos = StringUtil::pos(source, sourceLength, needle, _start, sourceLength); copyData(matchPos - 1, newNeedle->getStringData(), newLength); // step to the next search position _start = matchPos + newLength - 1; @@ -744,7 +746,7 @@ for (size_t i = 0; i < matches; i++) { // look for each instance and replace - size_t matchPos = StringUtil::pos(source, sourceLength, needle, _start); + size_t matchPos = StringUtil::pos(source, sourceLength, needle, _start, sourceLength); size_t copyLength = (matchPos - 1) - _start; /* get the next length to copy */ // if this skipped over characters, we need to copy those if (copyLength != 0) @@ -786,7 +788,7 @@ for (size_t i = 0; i < matches; i++) { // look for each instance and replace - size_t matchPos = StringUtil::pos(source, sourceLength, needle, _start); + size_t matchPos = StringUtil::pos(source, sourceLength, needle, _start, sourceLength); size_t copyLength = (matchPos - 1) - _start; /* get the next length to copy */ // if this skipped over characters, we need to copy those if (copyLength != 0) @@ -862,7 +864,7 @@ { // search for the next occurrence...which should be there because we // already know the count - size_t matchPos = StringUtil::caselessPos(source, sourceLength, needle, _start); + size_t matchPos = StringUtil::caselessPos(source, sourceLength, needle, _start, sourceLength); copyData(matchPos - 1, newNeedle->getStringData(), newLength); // step to the next search position _start = matchPos + newLength - 1; @@ -882,7 +884,7 @@ for (size_t i = 0; i < matches; i++) { // look for each instance and replace - size_t matchPos = StringUtil::caselessPos(source, sourceLength, needle, _start); + size_t matchPos = StringUtil::caselessPos(source, sourceLength, needle, _start, sourceLength); size_t copyLength = (matchPos - 1) - _start; /* get the next length to copy */ // if this skipped over characters, we need to copy those if (copyLength != 0) @@ -924,7 +926,7 @@ for (size_t i = 0; i < matches; i++) { // look for each instance and replace - size_t matchPos = StringUtil::caselessPos(source, sourceLength, needle, _start); + size_t matchPos = StringUtil::caselessPos(source, sourceLength, needle, _start, sourceLength); size_t copyLength = (matchPos - 1) - _start; /* get the next length to copy */ // if this skipped over characters, we need to copy those if (copyLength != 0) Modified: main/trunk/interpreter/classes/MutableBufferClass.hpp =================================================================== --- main/trunk/interpreter/classes/MutableBufferClass.hpp 2008-08-19 03:19:42 UTC (rev 3013) +++ main/trunk/interpreter/classes/MutableBufferClass.hpp 2008-08-19 03:42:38 UTC (rev 3014) @@ -83,10 +83,10 @@ RexxMutableBuffer *replaceAt(RexxObject *str, RexxObject *pos, RexxObject *len, RexxObject *pad); RexxMutableBuffer *mydelete(RexxObject*, RexxObject*); RexxString *substr(RexxInteger *startPosition, RexxInteger *len, RexxString *pad); - RexxInteger *lastPos(RexxString *needle, RexxInteger *_start); - RexxInteger *posRexx(RexxString *needle, RexxInteger *_start); - RexxInteger *caselessLastPos(RexxString *needle, RexxInteger *_start); - RexxInteger *caselessPos(RexxString *needle, RexxInteger *_start); + RexxInteger *lastPos(RexxString *needle, RexxInteger *_start, RexxInteger *_range); + RexxInteger *posRexx(RexxString *needle, RexxInteger *_start, RexxInteger *_range); + RexxInteger *caselessLastPos(RexxString *needle, RexxInteger *_start, RexxInteger *_range); + RexxInteger *caselessPos(RexxString *needle, RexxInteger *_start, RexxInteger *_range); RexxString *subchar(RexxInteger *startPosition); RexxInteger *getBufferSize() { return new_integer(bufferLength); } Modified: main/trunk/interpreter/classes/StringClass.hpp =================================================================== --- main/trunk/interpreter/classes/StringClass.hpp 2008-08-19 03:19:42 UTC (rev 3013) +++ main/trunk/interpreter/classes/StringClass.hpp 2008-08-19 03:42:38 UTC (rev 3014) @@ -260,14 +260,14 @@ RexxString *copies(RexxInteger *); RexxObject *dataType(RexxString *); - RexxInteger *lastPosRexx(RexxString *, RexxInteger *); - RexxInteger *caselessLastPosRexx(RexxString *, RexxInteger *); + RexxInteger *lastPosRexx(RexxString *, RexxInteger *, RexxInteger *); + RexxInteger *caselessLastPosRexx(RexxString *, RexxInteger *, RexxInteger *); size_t lastPos(RexxString *needle, size_t start); size_t caselessLastPos(RexxString *needle, size_t start); const char * caselessLastPos(const char *needle, size_t needleLen, const char *haystack, size_t haystackLen); - RexxInteger *posRexx(RexxString *, RexxInteger *); - RexxInteger *caselessPosRexx(RexxString *, RexxInteger *); + RexxInteger *posRexx(RexxString *, RexxInteger *, RexxInteger *); + RexxInteger *caselessPosRexx(RexxString *, RexxInteger *, RexxInteger *); size_t pos(RexxString *, size_t); size_t caselessPos(RexxString *, size_t); Modified: main/trunk/interpreter/classes/StringClassMisc.cpp =================================================================== --- main/trunk/interpreter/classes/StringClassMisc.cpp 2008-08-19 03:19:42 UTC (rev 3013) +++ main/trunk/interpreter/classes/StringClassMisc.cpp 2008-08-19 03:42:38 UTC (rev 3014) @@ -462,9 +462,9 @@ * @return the offset of the match position (origin 1). Returns 0 * if no match was found. */ -RexxInteger *RexxString::lastPosRexx(RexxString *needle, RexxInteger *_start) +RexxInteger *RexxString::lastPosRexx(RexxString *needle, RexxInteger *_start, RexxInteger *_range) { - return StringUtil::lastPosRexx(getStringData(), getLength(), needle, _start); + return StringUtil::lastPosRexx(getStringData(), getLength(), needle, _start, _range); } @@ -476,14 +476,15 @@ * * @return The match position. 0 means not found. */ -RexxInteger *RexxString::caselessLastPosRexx(RexxString *needle, RexxInteger *_start) +RexxInteger *RexxString::caselessLastPosRexx(RexxString *needle, RexxInteger *_start, RexxInteger *_range) { // validate that this is a good string argument needle = stringArgument(needle, ARG_ONE); // find out where to start the search. The default is at the very end. size_t startPos = optionalPositionArgument(_start, getLength(), ARG_TWO); + size_t range = optionalPositionArgument(_range, getLength(), ARG_THREE); // now perform the actual search. - return new_integer(caselessLastPos(needle, startPos)); + return new_integer(StringUtil::caselessLastPos(getStringData(), getLength(), needle, startPos, range)); } @@ -500,7 +501,7 @@ */ size_t RexxString::lastPos(RexxString *needle, size_t _start) { - return StringUtil::lastPos(getStringData(), getLength(), needle, _start); + return StringUtil::lastPos(getStringData(), getLength(), needle, _start, getLength()); } @@ -517,7 +518,7 @@ */ size_t RexxString::caselessLastPos(RexxString *needle, size_t _start) { - return StringUtil::caselessLastPos(getStringData(), getLength(), needle, _start); + return StringUtil::caselessLastPos(getStringData(), getLength(), needle, _start, getLength()); } RexxInteger *RexxString::countStrRexx(RexxString *needle) @@ -678,31 +679,34 @@ } -RexxInteger *RexxString::posRexx( - RexxString *needle, /* search string */ - RexxInteger *pstart) /* starting position */ +RexxInteger *RexxString::posRexx(RexxString *needle, RexxInteger *pstart, RexxInteger *range) /******************************************************************************/ /* Function: String class POS method/function */ /******************************************************************************/ { - return StringUtil::posRexx(getStringData(), getLength(), needle, pstart); + return StringUtil::posRexx(getStringData(), getLength(), needle, pstart, range); } -RexxInteger *RexxString::caselessPosRexx( - RexxString *needle, /* search string */ - RexxInteger *pstart) /* starting position */ -/******************************************************************************/ -/* Function: String class POS method/function */ -/******************************************************************************/ +/** + * Do a caseless search for one string in another. + * + * @param needle The search string. + * @param pstart The starting position for the search. + * @param range A maximum range for the search. + * + * @return The index of any match position, or 0 if not found. + */ +RexxInteger *RexxString::caselessPosRexx(RexxString *needle, RexxInteger *pstart, RexxInteger *range) { /* force needle to a string */ needle = stringArgument(needle, ARG_ONE); /* get the starting position */ size_t _start = optionalPositionArgument(pstart, 1, ARG_TWO); + size_t _range = optionalLengthArgument(range, getLength() - _start + 1, ARG_THREE); /* pass on to the primitive function */ /* and return as an integer object */ - return new_integer(StringUtil::caselessPos(getStringData(), getLength(), needle , _start - 1)); + return new_integer(StringUtil::caselessPos(getStringData(), getLength(), needle , _start - 1, _range)); } @@ -716,7 +720,7 @@ */ size_t RexxString::pos(RexxString *needle, size_t _start) { - return StringUtil::pos(getStringData(), getLength(), needle, _start); + return StringUtil::pos(getStringData(), getLength(), needle, _start, getLength()); } @@ -730,7 +734,7 @@ */ size_t RexxString::caselessPos(RexxString *needle, size_t _start) { - return StringUtil::caselessPos(getStringData(), getLength(), needle, _start); + return StringUtil::caselessPos(getStringData(), getLength(), needle, _start, getLength()); } Modified: main/trunk/interpreter/classes/StringUtil.cpp =================================================================== --- main/trunk/interpreter/classes/StringUtil.cpp 2008-08-19 03:19:42 UTC (rev 3013) +++ main/trunk/interpreter/classes/StringUtil.cpp 2008-08-19 03:42:38 UTC (rev 3014) @@ -127,15 +127,16 @@ * * @return An integer object giving the located position. */ -RexxInteger *StringUtil::posRexx(const char *stringData, size_t length, RexxString *needle, RexxInteger *pstart) +RexxInteger *StringUtil::posRexx(const char *stringData, size_t length, RexxString *needle, RexxInteger *pstart, RexxInteger *range) { /* force needle to a string */ needle = stringArgument(needle, ARG_ONE); /* get the starting position */ size_t _start = optionalPositionArgument(pstart, 1, ARG_TWO); + size_t _range = optionalLengthArgument(range, length - _start + 1, ARG_THREE); /* pass on to the primitive function */ /* and return as an integer object */ - return new_integer(pos(stringData, length, needle, _start - 1)); + return new_integer(pos(stringData, length, needle, _start - 1, _range)); } @@ -150,16 +151,18 @@ * * @return The offset of the located needle, or 0 if the needle doesn't exist. */ -size_t StringUtil::pos(const char *stringData, size_t haystack_length, RexxString *needle, size_t _start) +size_t StringUtil::pos(const char *stringData, size_t haystack_length, RexxString *needle, size_t _start, size_t _range) { // get the two working lengths size_t needle_length = needle->getLength(); + // make sure the range is capped + _range = Numerics::minVal(_range, haystack_length - _start + 1); // ok, there are a few quick checks we can perform. If the needle is // bigger than the haystack, or the needle is a null string or // our haystack length after adjusting to the starting position // zero, then we can quickly return zero. - if (needle_length > haystack_length + _start || needle_length == 0 || _start + needle_length > haystack_length) + if (_start > haystack_length || needle_length > _range || needle_length == 0) { return 0; } @@ -169,7 +172,7 @@ const char *needlepointer = needle->getStringData(); size_t location = _start + 1; // this is the match location as an index // calculate the number of probes we can make in this string - size_t count = (haystack_length - _start) - needle_length + 1; + size_t count = _range - needle_length + 1; // now scan while (count--) @@ -198,16 +201,18 @@ * * @return The offset of the located needle, or 0 if the needle doesn't exist. */ -size_t StringUtil::caselessPos(const char *stringData, size_t haystack_length, RexxString *needle, size_t _start) +size_t StringUtil::caselessPos(const char *stringData, size_t haystack_length, RexxString *needle, size_t _start, size_t _range) { // get the two working lengths size_t needle_length = needle->getLength(); + // make sure the range is capped + _range = Numerics::minVal(_range, haystack_length - _start + 1); // ok, there are a few quick checks we can perform. If the needle is // bigger than the haystack, or the needle is a null string or // our haystack length after adjusting to the starting position // zero, then we can quickly return zero. - if (needle_length > haystack_length + _start || needle_length == 0 || _start + needle_length > haystack_length) + if (_start > haystack_length || needle_length > _range || needle_length == 0) { return 0; } @@ -217,7 +222,7 @@ const char *needlepointer = needle->getStringData(); size_t location = _start + 1; // this is the match location as an index // calculate the number of probes we can make in this string - size_t count = (haystack_length - _start) - needle_length + 1; + size_t count = _range - needle_length + 1; // now scan while (count--) @@ -246,13 +251,14 @@ * * @return An integer object giving the located position. */ -RexxInteger *StringUtil::lastPosRexx(const char *stringData, size_t haystackLen, RexxString *needle, RexxInteger *_start) +RexxInteger *StringUtil::lastPosRexx(const char *stringData, size_t haystackLen, RexxString *needle, RexxInteger *_start, RexxInteger *_range) { needle = stringArgument(needle, ARG_ONE); // find out where to start the search. The default is at the very end. size_t startPos = optionalPositionArgument(_start, haystackLen, ARG_TWO); + size_t range = optionalPositionArgument(_range, haystackLen, ARG_THREE); // now perform the actual search. - return new_integer(lastPos(stringData, haystackLen, needle, startPos)); + return new_integer(lastPos(stringData, haystackLen, needle, startPos, range)); } @@ -267,12 +273,12 @@ * * @return The offset of the located needle, or 0 if the needle doesn't exist. */ -size_t StringUtil::lastPos(const char *stringData, size_t haystackLen, RexxString *needle, size_t _start) +size_t StringUtil::lastPos(const char *stringData, size_t haystackLen, RexxString *needle, size_t _start, size_t range) { size_t needleLen = needle->getLength(); /* and get the length too */ // no match possible if either string is null - if (needleLen == 0 || haystackLen == 0) + if (needleLen == 0 || haystackLen == 0 || needleLen > range) { return 0; } @@ -280,8 +286,11 @@ { // get the start position for the search. haystackLen = Numerics::minVal(_start, haystackLen); + range = Numerics::minVal(range, haystackLen); + // adjust the starting point + const char *startPoint = stringData + haystackLen - range; /* do the search */ - const char *matchLocation = lastPos(needle->getStringData(), needleLen, stringData, haystackLen); + const char *matchLocation = lastPos(needle->getStringData(), needleLen, startPoint, haystackLen); if (matchLocation == NULL) { return 0; @@ -346,12 +355,12 @@ * * @return The offset of the located needle, or 0 if the needle doesn't exist. */ -size_t StringUtil::caselessLastPos(const char *stringData, size_t haystackLen, RexxString *needle, size_t _start) +size_t StringUtil::caselessLastPos(const char *stringData, size_t haystackLen, RexxString *needle, size_t _start, size_t range) { size_t needleLen = needle->getLength(); /* and get the length too */ // no match possible if either string is null - if (needleLen == 0 || haystackLen == 0) + if (needleLen == 0 || haystackLen == 0 || needleLen > range) { return 0; } @@ -359,8 +368,11 @@ { // get the start position for the search. haystackLen = Numerics::minVal(_start, haystackLen); + range = Numerics::minVal(range, haystackLen); + // adjust the starting point + const char *startPoint = stringData + haystackLen - range; /* do the search */ - const char *matchLocation = caselessLastPos(needle->getStringData(), needleLen, stringData, haystackLen); + const char *matchLocation = caselessLastPos(needle->getStringData(), needleLen, startPoint, haystackLen); if (matchLocation == NULL) { return 0; @@ -1292,12 +1304,12 @@ { size_t count = 0; /* no matches yet */ /* get the first match position */ - size_t matchPos = pos(hayStack, hayStackLength, needle, 0); + size_t matchPos = pos(hayStack, hayStackLength, needle, 0, hayStackLength); while (matchPos != 0) { count = count + 1; /* count this match */ // step to the new position and search - matchPos = pos(hayStack, hayStackLength, needle, matchPos + needle->getLength() - 1); + matchPos = pos(hayStack, hayStackLength, needle, matchPos + needle->getLength() - 1, hayStackLength); } return count; /* return the match count */ } @@ -1317,12 +1329,12 @@ { size_t count = 0; /* no matches yet */ /* get the first match position */ - size_t matchPos = caselessPos(hayStack, hayStackLength, needle, 0); + size_t matchPos = caselessPos(hayStack, hayStackLength, needle, 0, hayStackLength); while (matchPos != 0) { count = count + 1; /* count this match */ // step to the new position and search - matchPos = caselessPos(hayStack, hayStackLength, needle, matchPos + needle->getLength() - 1); + matchPos = caselessPos(hayStack, hayStackLength, needle, matchPos + needle->getLength() - 1, hayStackLength); } return count; /* return the match count */ } Modified: main/trunk/interpreter/classes/StringUtil.hpp =================================================================== --- main/trunk/interpreter/classes/StringUtil.hpp 2008-08-19 03:19:42 UTC (rev 3013) +++ main/trunk/interpreter/classes/StringUtil.hpp 2008-08-19 03:42:38 UTC (rev 3014) @@ -51,15 +51,15 @@ { public: static RexxString *substr(const char *, size_t, RexxInteger *, RexxInteger *, RexxString *); - static RexxInteger *posRexx(const char *stringData, size_t length, RexxString *needle, RexxInteger *pstart); - static size_t pos(const char *stringData, size_t haystack_length, RexxString *needle, size_t _start); - static size_t caselessPos(const char *stringData, size_t haystack_length, RexxString *needle, size_t _start); - static RexxInteger *lastPosRexx(const char *stringData, size_t haystackLen, RexxString *needle, RexxInteger *_start); - static size_t lastPos(const char *stringData, size_t hastackLen, RexxString *needle, size_t _start); + static RexxInteger *posRexx(const char *stringData, size_t length, RexxString *needle, RexxInteger *pstart, RexxInteger *range); + static size_t pos(const char *stringData, size_t haystack_length, RexxString *needle, size_t _start, size_t _range); + static size_t caselessPos(const char *stringData, size_t haystack_length, RexxString *needle, size_t _start, size_t _range); + static RexxInteger *lastPosRexx(const char *stringData, size_t haystackLen, RexxString *needle, RexxInteger *_start, RexxInteger *_range); + static size_t lastPos(const char *stringData, size_t hastackLen, RexxString *needle, size_t _start, size_t _range); static const char *lastPos(const char *needle, size_t needleLen, const char *haystack, size_t haystackLen); static RexxString *subchar(const char *stringData, size_t stringLength, RexxInteger *positionArg); static RexxArray *makearray(const char *start, size_t length, RexxString *separator); - static size_t caselessLastPos(const char *stringData, size_t hastackLen, RexxString *needle, size_t _start); + static size_t caselessLastPos(const char *stringData, size_t hastackLen, RexxString *needle, size_t _start, size_t range); static const char * caselessLastPos(const char *needle, size_t needleLen, const char *haystack, size_t haystackLen); static int caselessCompare(const char *, const char *, size_t); static int hexDigitToInt(char ch); Modified: main/trunk/interpreter/expression/BuiltinFunctions.cpp =================================================================== --- main/trunk/interpreter/expression/BuiltinFunctions.cpp 2008-08-19 03:19:42 UTC (rev 3013) +++ main/trunk/interpreter/expression/BuiltinFunctions.cpp 2008-08-19 03:42:38 UTC (rev 3014) @@ -212,10 +212,11 @@ } #define POS_MIN 2 -#define POS_MAX 3 +#define POS_MAX 4 #define POS_needle 1 #define POS_haystack 2 #define POS_start 3 +#define POS_range 4 BUILTIN(POS) { @@ -225,8 +226,9 @@ /* get string for target */ RexxString *haystack = required_string(POS, haystack); RexxInteger *start = optional_integer(POS, start);/* start position is optional */ + RexxInteger *range = optional_integer(POS, range); /* go perform the pos function */ - return haystack->posRexx(needle, start); + return haystack->posRexx(needle, start, range); } #define LASTPOS_MIN 2 @@ -234,6 +236,7 @@ #define LASTPOS_needle 1 #define LASTPOS_haystack 2 #define LASTPOS_start 3 +#define LASTPOS_range 4 BUILTIN(LASTPOS) { @@ -244,8 +247,9 @@ RexxString *haystack = required_string(LASTPOS, haystack); /* start position is optional */ RexxInteger *start = optional_integer(LASTPOS, start); + RexxInteger *range = optional_integer(LASTPOS, range); /* go perform the lastpos function */ - return haystack->lastPosRexx(needle, start); + return haystack->lastPosRexx(needle, start, range); } #define REVERSE_MIN 1 Modified: main/trunk/interpreter/memory/Setup.cpp =================================================================== --- main/trunk/interpreter/memory/Setup.cpp 2008-08-19 03:19:42 UTC (rev 3013) +++ main/trunk/interpreter/memory/Setup.cpp 2008-08-19 03:42:38 UTC (rev 3014) @@ -837,10 +837,10 @@ defineKernelMethod(CHAR_COPIES ,TheStringBehaviour, CPPM(RexxString::copies), 1); defineKernelMethod(CHAR_COUNTSTR ,TheStringBehaviour, CPPM(RexxString::countStrRexx), 1); defineKernelMethod(CHAR_CASELESSCOUNTSTR ,TheStringBehaviour, CPPM(RexxString::caselessCountStrRexx), 1); - defineKernelMethod(CHAR_LASTPOS ,TheStringBehaviour, CPPM(RexxString::lastPosRexx), 2); - defineKernelMethod(CHAR_POS ,TheStringBehaviour, CPPM(RexxString::posRexx), 2); - defineKernelMethod(CHAR_CASELESSLASTPOS ,TheStringBehaviour, CPPM(RexxString::caselessLastPosRexx), 2); - defineKernelMethod(CHAR_CASELESSPOS ,TheStringBehaviour, CPPM(RexxString::caselessPosRexx), 2); + defineKernelMethod(CHAR_LASTPOS ,TheStringBehaviour, CPPM(RexxString::lastPosRexx), 3); + defineKernelMethod(CHAR_POS ,TheStringBehaviour, CPPM(RexxString::posRexx), 3); + defineKernelMethod(CHAR_CASELESSLASTPOS ,TheStringBehaviour, CPPM(RexxString::caselessLastPosRexx), 3); + defineKernelMethod(CHAR_CASELESSPOS ,TheStringBehaviour, CPPM(RexxString::caselessPosRexx), 3); defineKernelMethod(CHAR_TRANSLATE ,TheStringBehaviour, CPPM(RexxString::translate), 5); defineKernelMethod(CHAR_VERIFY ,TheStringBehaviour, CPPM(RexxString::verify), 4); defineKernelMethod(CHAR_BITAND ,TheStringBehaviour, CPPM(RexxString::bitAnd), 2); @@ -930,10 +930,10 @@ defineKernelMethod(CHAR_REPLACEAT ,TheMutableBufferBehaviour, CPPM(RexxMutableBuffer::replaceAt), 4); defineKernelMethod(CHAR_DELETE ,TheMutableBufferBehaviour, CPPM(RexxMutableBuffer::mydelete), 2); defineKernelMethod(CHAR_SUBSTR ,TheMutableBufferBehaviour, CPPM(RexxMutableBuffer::substr), 3); - defineKernelMethod(CHAR_POS ,TheMutableBufferBehaviour, CPPM(RexxMutableBuffer::posRexx), 2); - defineKernelMethod(CHAR_LASTPOS ,TheMutableBufferBehaviour, CPPM(RexxMutableBuffer::lastPos), 2); - defineKernelMethod(CHAR_CASELESSPOS ,TheMutableBufferBehaviour, CPPM(RexxMutableBuffer::caselessPos), 2); - defineKernelMethod(CHAR_CASELESSLASTPOS ,TheMutableBufferBehaviour, CPPM(RexxMutableBuffer::caselessLastPos), 2); + defineKernelMethod(CHAR_POS ,TheMutableBufferBehaviour, CPPM(RexxMutableBuffer::posRexx), 3); + defineKernelMethod(CHAR_LASTPOS ,TheMutableBufferBehaviour, CPPM(RexxMutableBuffer::lastPos), 3); + defineKernelMethod(CHAR_CASELESSPOS ,TheMutableBufferBehaviour, CPPM(RexxMutableBuffer::caselessPos), 3); + defineKernelMethod(CHAR_CASELESSLASTPOS ,TheMutableBufferBehaviour, CPPM(RexxMutableBuffer::caselessLastPos), 3); defineKernelMethod(CHAR_SUBCHAR ,TheMutableBufferBehaviour, CPPM(RexxMutableBuffer::subchar), 1); defineKernelMethod(CHAR_GETBUFFERSIZE ,TheMutableBufferBehaviour, CPPM(RexxMutableBuffer::getBufferSize), 0); defineKernelMethod(CHAR_SETBUFFERSIZE ,TheMutableBufferBehaviour, CPPM(RexxMutableBuffer::setBufferSize), 1); This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |
From: <mie...@us...> - 2008-08-19 03:19:33
|
Revision: 3013 http://oorexx.svn.sourceforge.net/oorexx/?rev=3013&view=rev Author: miesfeld Date: 2008-08-19 03:19:42 +0000 (Tue, 19 Aug 2008) Log Message: ----------- Fix a little over-zealous code cleanup. Modified Paths: -------------- main/trunk/interpreter/expression/BuiltinFunctions.cpp Modified: main/trunk/interpreter/expression/BuiltinFunctions.cpp =================================================================== --- main/trunk/interpreter/expression/BuiltinFunctions.cpp 2008-08-19 03:17:43 UTC (rev 3012) +++ main/trunk/interpreter/expression/BuiltinFunctions.cpp 2008-08-19 03:19:42 UTC (rev 3013) @@ -2171,7 +2171,6 @@ bool added; /* get a stream for this name */ RexxObject *stream = resolve_stream(name, context, stack, true, NULL, &added); - RexxString *option; if (option != OREF_NULL) { This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |
From: <mie...@us...> - 2008-08-19 03:17:34
|
Revision: 3012 http://oorexx.svn.sourceforge.net/oorexx/?rev=3012&view=rev Author: miesfeld Date: 2008-08-19 03:17:43 +0000 (Tue, 19 Aug 2008) Log Message: ----------- Be sure the OLEObject external methods return immediately after raising an exception. Modified Paths: -------------- main/trunk/extensions/platform/windows/ole/events.cpp main/trunk/extensions/platform/windows/ole/orexxole.c Modified: main/trunk/extensions/platform/windows/ole/events.cpp =================================================================== --- main/trunk/extensions/platform/windows/ole/events.cpp 2008-08-19 02:29:27 UTC (rev 3011) +++ main/trunk/extensions/platform/windows/ole/events.cpp 2008-08-19 03:17:43 UTC (rev 3012) @@ -55,7 +55,7 @@ extern VOID ORexxOleFree(PVOID ptr); extern RexxObjectPtr Variant2Rexx(RexxThreadContext *, VARIANT *pVariant); -extern VOID Rexx2Variant(RexxThreadContext *, RexxObjectPtr RxObject, VARIANT *pVariant, VARTYPE DestVt, size_t iArgPos); +extern bool Rexx2Variant(RexxThreadContext *, RexxObjectPtr RxObject, VARIANT *pVariant, VARTYPE DestVt, size_t iArgPos); // CTOR // set reference count to one @@ -249,7 +249,7 @@ { i++; } - // put value into out parameter + // put value into out parameter TODO what if there is an exception? Rexx2Variant(context, rxResult,&pDispParams->rgvarg[i],pDispParams->rgvarg[i].vt,-1); } else if (context->IsArray(rxResult)) @@ -267,6 +267,7 @@ { if (pList->pusOptFlags[j] & PARAMFLAG_FOUT) { + // TODO what if there is an exception? Rexx2Variant(context, context->ArrayAt(rxArray, i),&pDispParams->rgvarg[j],pDispParams->rgvarg[j].vt,-1); i++; } Modified: main/trunk/extensions/platform/windows/ole/orexxole.c =================================================================== --- main/trunk/extensions/platform/windows/ole/orexxole.c 2008-08-19 02:29:27 UTC (rev 3011) +++ main/trunk/extensions/platform/windows/ole/orexxole.c 2008-08-19 03:17:43 UTC (rev 3012) @@ -63,6 +63,8 @@ long iInstanceCount = 0; // count number of created OLE objects +typedef enum {FailureReturn, SuccessReturn, ExceptionReturn} ThreeStateReturn; + //****************************************************************************** // function prototypes for local functions //****************************************************************************** @@ -85,13 +87,13 @@ BOOL fFindConstant(const char *pszConstName, POLECLASSINFO pClsInfo, PPOLECONSTINFO ppConstInfo ); RexxObjectPtr Variant2Rexx(RexxThreadContext *context, VARIANT *pVariant); -void Rexx2Variant(RexxThreadContext *context, RexxObjectPtr RxObject, VARIANT *pVariant, VARTYPE DestVt, size_t iArgPos); +bool Rexx2Variant(RexxThreadContext *context, RexxObjectPtr RxObject, VARIANT *pVariant, VARTYPE DestVt, size_t iArgPos); bool createEmptySafeArray(RexxThreadContext *, VARIANT *); -BOOL fRexxArray2SafeArray(RexxThreadContext *context, RexxObjectPtr RxArray, VARIANT *VarArray, size_t iArgPos); +bool RexxArray2SafeArray(RexxThreadContext *context, RexxObjectPtr RxArray, VARIANT *VarArray, size_t iArgPos); BOOL fExploreTypeAttr( ITypeInfo *pTypeInfo, TYPEATTR *pTypeAttr, POLECLASSINFO pClsInfo ); VARTYPE getUserDefinedVT( ITypeInfo *pTypeInfo, HREFTYPE hrt ); BOOL fExploreTypeInfo( ITypeInfo *pTypeInfo, POLECLASSINFO pClsInfo ); -BOOL checkForOverride(RexxThreadContext *, VARIANT *, RexxObjectPtr , VARTYPE, RexxObjectPtr *, VARTYPE * ); +ThreeStateReturn checkForOverride(RexxThreadContext *, VARIANT *, RexxObjectPtr , VARTYPE, RexxObjectPtr *, VARTYPE * ); BOOL isOutParam(RexxThreadContext *, RexxObjectPtr , POLEFUNCINFO, size_t); VOID handleVariantClear(RexxMethodContext *, VARIANT *, RexxObjectPtr ); __inline BOOL okayToClear(RexxMethodContext *, RexxObjectPtr ); @@ -1627,7 +1629,7 @@ * Setting a VT_BOOL's value to 1 for true does not produce the correct * result. */ -void Rexx2Variant(RexxThreadContext *context, RexxObjectPtr _RxObject, VARIANT *pVariant, VARTYPE _DestVt, size_t iArgPos) +bool Rexx2Variant(RexxThreadContext *context, RexxObjectPtr _RxObject, VARIANT *pVariant, VARTYPE _DestVt, size_t iArgPos) { BOOL fDone = FALSE; BOOL fByRef = FALSE; @@ -1636,9 +1638,14 @@ RexxObjectPtr RxObject; VARTYPE DestVt; - if ( checkForOverride(context, pVariant, _RxObject, _DestVt, &RxObject, &DestVt) ) + switch ( checkForOverride(context, pVariant, _RxObject, _DestVt, &RxObject, &DestVt) ) { - return; + case SuccessReturn : + return true; + case ExceptionReturn : + return false; + default: + ; // Drop through } if (DestVt & VT_BYREF) @@ -1655,7 +1662,7 @@ /* omitted argument */ V_VT(pVariant) = VT_ERROR; V_ERROR(pVariant) = DISP_E_PARAMNOTFOUND; - return; + return true; } RexxClassObject oleClass = context->FindClass("OLEOBJECT"); @@ -1677,18 +1684,14 @@ V_VT(pVariant) = VT_DISPATCH; V_DISPATCH(pVariant)->AddRef(); } - return; + return true; } } /* or maybe this is an array? */ if (context->IsArray(RxObject)) { - // if this converts, return - if (fRexxArray2SafeArray(context, RxObject, pVariant, iArgPos)) // byRefCheck!!!! - { - return; - } + return RexxArray2SafeArray(context, RxObject, pVariant, iArgPos); // byRefCheck!!!! } /* if no target type is specified try original REXX types */ @@ -1706,7 +1709,7 @@ V_VT(pVariant) = VT_BOOL; V_BOOL(pVariant) = (RxObject==context->True()) ? VARIANT_TRUE : VARIANT_FALSE; } - return; + return true; } wholenumber_t intval; @@ -1723,7 +1726,7 @@ V_VT(pVariant) = VT_I4; V_I4(pVariant) = (LONG)intval; } - return; + return true; } double val; @@ -1739,7 +1742,7 @@ V_VT(pVariant) = VT_R8; V_R8(pVariant) = val; } - return; + return true; } } @@ -1783,7 +1786,7 @@ V_VT(pVariant) = VT_BOOL; V_BOOL(pVariant) = targetValue; } - return; + return true; } LPOLESTR lpUniBuffer = NULL; @@ -1823,7 +1826,7 @@ V_R4(pVariant) = (float)val; } } - return; + return true; } } @@ -1861,7 +1864,9 @@ V_VT(pVariant) = VT_ERROR; V_ERROR(pVariant) = DISP_E_PARAMNOTFOUND; context->RaiseException1(Rexx_Error_Rexx2Variant, RxObject); + return false; } + return true; } @@ -1896,9 +1901,8 @@ } -BOOL fRexxArray2SafeArray(RexxThreadContext *context, RexxObjectPtr RxArray, VARIANT *VarArray, size_t iArgPos) +bool RexxArray2SafeArray(RexxThreadContext *context, RexxObjectPtr RxArray, VARIANT *VarArray, size_t iArgPos) { - BOOL fDone = FALSE; wholenumber_t lDimensions; PLONG lpIndices; // vector of indices wholenumber_t lSize = 1; // number of elements that need to be considered @@ -1912,6 +1916,7 @@ BOOL fCarryBit; context->ObjectToNumber(context->SendMessage0(RxArray,"DIMENSION"), &lDimensions); + /* An empty array is valid, and necessary for some OLE Automation objects. */ if ( lDimensions == 0 ) { @@ -1923,6 +1928,14 @@ /* alloc an array of SAFEARRAYBOUNDs */ pArrayBounds=(SAFEARRAYBOUND*) ORexxOleAlloc(sizeof(SAFEARRAYBOUND)*lDimensions); + if ( ! lpIndices || ! pArrayBounds ) + { + ORexxOleFree(pArrayBounds); + ORexxOleFree(lpIndices); + context->RaiseException(Rexx_Error_System_resources); + return false; + } + /* get necessary information on array and set indices vector to initial state */ for (i=0;i<lDimensions;i++) { @@ -1938,68 +1951,78 @@ /* create the SafeArray */ pSafeArray = SafeArrayCreate(VT_VARIANT,(UINT) lDimensions, pArrayBounds); + if ( ! pSafeArray ) + { + ORexxOleFree(pArrayBounds); + ORexxOleFree(lpIndices); + context->RaiseException(Rexx_Error_System_resources); + return false; + } - if (pSafeArray) + V_VT(VarArray) = VT_ARRAY | VT_VARIANT; + V_ARRAY(VarArray) = pSafeArray; + + /* get each element and transform it into a VARIANT */ + for (i=0; i<lSize; i++) { - V_VT(VarArray) = VT_ARRAY | VT_VARIANT; - V_ARRAY(VarArray) = pSafeArray; + RexxArrayObject argArray = context->NewArray(lDimensions); + for (j=0; j < lDimensions; j++) + { + // put j-th index in msg array + context->ArrayPut(argArray, context->NumberToObject(lpIndices[j]+1), j+1); + } + /* get item from RexxArray */ + RexxItem = context->SendMessage1(RxArray, "AT", argArray); - /* get each element and transform it into a VARIANT */ - for (i=0; i<lSize; i++) + /* convert it into a VARIANT */ + VariantInit(&sVariant); + + if (RexxItem == context->Nil()) { - RexxArrayObject argArray = context->NewArray(lDimensions); - for (j=0; j < lDimensions; j++) + // special handling of .nil (avoid VT_ERROR) + V_VT(&sVariant)=VT_EMPTY; + } + else + { + if ( ! Rexx2Variant(context, RexxItem, &sVariant, VT_EMPTY, 0) ) { - context->ArrayPut(argArray, context->NumberToObject(lpIndices[j]+1), j+1); // put j-th index in msg array + ORexxOleFree(pArrayBounds); + ORexxOleFree(lpIndices); + return false; } - /* get item from RexxArray */ - RexxItem = context->SendMessage1(RxArray, "AT", argArray); + } - /* convert it into a VARIANT */ - VariantInit(&sVariant); + /* set into the SafeArray */ + hResult = SafeArrayPutElement(pSafeArray, lpIndices, &sVariant); + if (FAILED(hResult)) + { + // safearrayputelement failed - action required? + } + /* clear the local copy */ + VariantClear(&sVariant); - if (RexxItem == context->Nil()) // special handling of .nil (avoid VT_ERROR) + /* increment indices vector */ + fCarryBit=TRUE; + j=0; + while (fCarryBit && j<lDimensions) + { + if (lpIndices[j] == (long) pArrayBounds[j].cElements - 1) { - V_VT(&sVariant)=VT_EMPTY; + lpIndices[j] = 0; } else { - Rexx2Variant(context, RexxItem, &sVariant, VT_EMPTY, 0); + lpIndices[j]++; + fCarryBit=FALSE; } - - /* set into the SafeArray */ - hResult = SafeArrayPutElement(pSafeArray, lpIndices, &sVariant); - if (FAILED(hResult)) - { - // safearrayputelement failed - action required? - } - /* clear the local copy */ - VariantClear(&sVariant); - - /* increment indices vector */ - fCarryBit=TRUE; - j=0; - while (fCarryBit && j<lDimensions) - { - if (lpIndices[j] == (long) pArrayBounds[j].cElements - 1) - { - lpIndices[j] = 0; - } - else - { - lpIndices[j]++; - fCarryBit=FALSE; - } - j++; - } + j++; } - fDone = TRUE; } ORexxOleFree(pArrayBounds); ORexxOleFree(lpIndices); - return fDone; + return true; } BOOL fExploreTypeAttr( ITypeInfo *pTypeInfo, TYPEATTR *pTypeAttr, POLECLASSINFO pClsInfo ) @@ -3372,14 +3395,18 @@ if (pTypeInfo && pFuncInfo) { - DestVt = (i< (size_t)pFuncInfo->iParmCount)?pFuncInfo->pOptVt[i]:VT_EMPTY; + DestVt = (i < (size_t)pFuncInfo->iParmCount) ? pFuncInfo->pOptVt[i] : VT_EMPTY; } else { DestVt = VT_EMPTY; } - Rexx2Variant(context->threadContext, arrItem, &(pVarArgs[iArgCount - i - 1]), DestVt, i + 1); + if ( ! Rexx2Variant(context->threadContext, arrItem, &(pVarArgs[iArgCount - i - 1]), DestVt, i + 1) ) + { + // An exception was raised. + goto clean_up_exit; + } /* If an out parameter, the variant must be passed as a reference. The * original input variant is saved so that, if a new value is returned, @@ -3606,13 +3633,17 @@ * * @param pDestVt [Returned] The real VT type to coerce the ooRexx object to. * - * @return True, the conversion is complete, or false, the conversion - * is not complete - continue with the automatic conversion. + * @return SuccessReturn: the conversion is complete. + * + * FailureReturn: the conversion is not complete - continue + * with the automatic conversion. + * + * ExceptionReturn: an exception is raised. */ -BOOL checkForOverride(RexxThreadContext *context, VARIANT *pVariant, RexxObjectPtr RxObject, VARTYPE DestVt, - RexxObjectPtr *pRxObject, VARTYPE *pDestVt ) +ThreeStateReturn checkForOverride(RexxThreadContext *context, VARIANT *pVariant, RexxObjectPtr RxObject, + VARTYPE DestVt, RexxObjectPtr *pRxObject, VARTYPE *pDestVt ) { - BOOL converted = FALSE; + ThreeStateReturn converted = FailureReturn; // needed for instance of tests RexxClassObject variantClass = context->FindClass("OLEVARIANT"); @@ -3643,12 +3674,12 @@ { case VT_NULL : V_VT(pVariant) = VT_NULL; - converted = TRUE; + converted = SuccessReturn; break; case VT_EMPTY : V_VT(pVariant) = VT_EMPTY; - converted = TRUE; + converted = SuccessReturn; break; case VT_DISPATCH : @@ -3662,6 +3693,7 @@ if ( ! ppDisp ) { context->RaiseException(Rexx_Error_System_resources); + return ExceptionReturn; } *ppDisp = (IDispatch *)NULL; @@ -3676,7 +3708,7 @@ /* ooRexx, not VariantClear, must clear this variant. */ context->SendMessage1(RxObject, "!CLEARVARIANT_=", context->False()); context->SendMessage1(RxObject, "!VARIANTPOINTER_=", context->NewPointer(ppDisp)); - converted = TRUE; + converted = SuccessReturn; break; } /* Let default conversion handle non-nil. */ @@ -3693,6 +3725,7 @@ if ( ! ppU ) { context->RaiseException(Rexx_Error_System_resources); + return ExceptionReturn; } *ppU = (IUnknown *)NULL; @@ -3707,7 +3740,7 @@ /* ooRexx, not VariantClear, must clear this variant. */ context->SendMessage1(RxObject, "!CLEARVARIANT_=", context->False()); context->SendMessage1(RxObject, "!VARIANTPOINTER_=", context->NewPointer(ppU)); - converted = TRUE; + converted = SuccessReturn; break; } /* Let default conversion handle non-nil. */ This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |
From: <wda...@us...> - 2008-08-19 02:29:17
|
Revision: 3011 http://oorexx.svn.sourceforge.net/oorexx/?rev=3011&view=rev Author: wdashley Date: 2008-08-19 02:29:27 +0000 (Tue, 19 Aug 2008) Log Message: ----------- ArtifactID: None Comment: More TreeModel methods. Modified Paths: -------------- incubator/RexxGTK/4x/grxtreemodel.cpp incubator/RexxGTK/4x/grxtreeview.cpp incubator/RexxGTK/4x/rexxgtk.cls incubator/RexxGTK/4x/rexxgtk.cpp incubator/RexxGTK/4x/rexxgtk.h Modified: incubator/RexxGTK/4x/grxtreemodel.cpp =================================================================== --- incubator/RexxGTK/4x/grxtreemodel.cpp 2008-08-18 21:55:30 UTC (rev 3010) +++ incubator/RexxGTK/4x/grxtreemodel.cpp 2008-08-19 02:29:27 UTC (rev 3011) @@ -232,7 +232,7 @@ **/ RexxMethod2(logical_t, // Return type GrxTreePathIsAncestor, // Object_method name - RexxObjectPtr, obj, // Note to test + RexxObjectPtr, obj, // Node to test CSELF, self) // GTK self { GtkTreePath *node = (GtkTreePath *)context->ObjectToCSelf(obj); @@ -250,8 +250,8 @@ * @return Boolean **/ RexxMethod2(logical_t, // Return type - GrxTreePathIdDescendant, // Object_method name - RexxObjectPtr, obj, // Note to test + GrxTreePathIsDescendant, // Object_method name + RexxObjectPtr, obj, // Node to test CSELF, self) // GTK self { GtkTreePath *node = (GtkTreePath *)context->ObjectToCSelf(obj); @@ -259,3 +259,121 @@ return gtk_tree_path_is_descendant((GtkTreePath *)self, node); } +/** + * Method: reference_new + * + * Get a tree row reference. + * + * @param node The node to test + * + * @return Boolean + **/ +RexxMethod3(int, // Return type + GrxTreeModelRowReferenceNew, // Object_method name + OSELF, oself, // GTK self + CSELF, cself, // GTK self + RexxObjectPtr, path) // Tree path +{ + GtkTreePath *node = (GtkTreePath *)context->ObjectToCSelf(path); + + // Create the Rexx object + context->SendMessage2(oself, "create_tree_row_reference", + (RexxObjectPtr)context->NewPointer(cself), + (RexxObjectPtr)context->NewPointer(node)); + + return 0; +} + +/** + * Method: init + * + * Create a tree row reference. + * + * @param pointer The pointer + * + * @return Zero. + **/ +RexxMethod3(int, // Return type + GrxTreeRowReferenceNewFromPtr, // Object_method name + OSELF, self, // Self + RexxObjectPtr, ptr1, // Model pointer + RexxObjectPtr, ptr2) // Path pointer +{ + GtkTreeModel *model = (GtkTreeModel *)context->PointerValue((RexxPointerObject)ptr1); + GtkTreePath *path = (GtkTreePath *)context->PointerValue((RexxPointerObject)ptr2); + + GtkTreeRowReference *ref = gtk_tree_row_reference_new(model, path); + + // Save ourself + context->SetObjectVariable("CSELF", context->NewPointer(ref)); + + return 0; +} + +/** + * Method: valid + * + * Is the row reference valid. + * + * @return Boolean + **/ +RexxMethod1(logical_t, // Return type + GrxTreeRowReferenceValid, // Object_method name + CSELF, self) // GTK self +{ + + return gtk_tree_row_reference_valid((GtkTreeRowReference *)self); +} + +/** + * Method: init + * + * Create a tree model. + * + * @param pointer The pointer + * + * @return Zero. + **/ +RexxMethod2(int, // Return type + GrxTreeModelNewFromPtr, // Object_method name + OSELF, self, // Self + RexxObjectPtr, ptr) // Pointer +{ + // Save ourself + context->SetObjectVariable("CSELF", + (RexxObjectPtr)context->PointerValue((RexxPointerObject)ptr)); + + return 0; +} + +/** + * Method: get_n_columns + * + * Get the number of columns. + * + * @return Zero. + **/ +RexxMethod1(int, // Return type + GrxTreeModelGetNColumns, // Object_method name + CSELF, self) // Self +{ + return gtk_tree_model_get_n_columns((GtkTreeModel *)self); +} + +/** + * Method: get_column_type + * + * Get the column type. + * + * @param idx The column index + * + * @return Zero. + **/ +RexxMethod2(int, // Return type + GrxTreeModelGetColumnType, // Object_method name + CSELF, self, // Self + int, idx) // Column index +{ + return gtk_tree_model_get_column_type((GtkTreeModel *)self, idx); +} + Modified: incubator/RexxGTK/4x/grxtreeview.cpp =================================================================== --- incubator/RexxGTK/4x/grxtreeview.cpp 2008-08-18 21:55:30 UTC (rev 3010) +++ incubator/RexxGTK/4x/grxtreeview.cpp 2008-08-19 02:29:27 UTC (rev 3011) @@ -306,6 +306,25 @@ } /** + * Method: get_model + * + * Get the model for the tree. + * + * @return Treemodel object + **/ +RexxMethod2(RexxObjectPtr, // Return type + GrxTreeViewGetModel, // Object_method name + CSELF, cself, // GTK self + OSELF, oself) // GTK self +{ + GtkTreeModel *model = (GtkTreeModel *)gtk_tree_view_get_model(GTK_TREE_VIEW(cself)); + + // Create the Rexx object + return context->SendMessage1(oself, "create_tree_model", + context->NewPointer((RexxPointerObject)model)); +} + +/** * Method: expand_all * * Expand all levels of the tree. Modified: incubator/RexxGTK/4x/rexxgtk.cls =================================================================== --- incubator/RexxGTK/4x/rexxgtk.cls 2008-08-18 21:55:30 UTC (rev 3010) +++ incubator/RexxGTK/4x/rexxgtk.cls 2008-08-19 02:29:27 UTC (rev 3011) @@ -2882,8 +2882,13 @@ ::METHOD remove_column EXTERNAL "LIBRARY rexxgtk GrxTreeViewRemoveColumn" ::METHOD set_model EXTERNAL "LIBRARY rexxgtk GrxTreeViewSetModel" ::METHOD expand_all EXTERNAL "LIBRARY rexxgtk GrxTreeViewExpandAll" +::METHOD get_model EXTERNAL "LIBRARY rexxgtk GrxTreePathGetModel" ::METHOD signal_connect EXTERNAL "LIBRARY rexxgtk GrxTreeViewSignalConnect" +::model create_tree_model private +use strict arg ptr +return GtkTreeModel~new(ptr) + -- The following are the methods that can be connected to signals. By default -- they do nothing. @@ -3220,4 +3225,37 @@ ::METHOD depth EXTERNAL "LIBRARY rexxgtk GrxTreePathGetDepth" ::METHOD is_ancestor EXTERNAL "LIBRARY rexxgtk GrxTreePathIsAncestor" ::METHOD is_descendant EXTERNAL "LIBRARY rexxgtk GrxTreePathIsDescendant" +::METHOD get_model EXTERNAL "LIBRARY rexxgtk GrxTreePathGetModel" +::model create_tree_model private +use strict arg ptr +return GtkTreeModel~new(ptr) + + +/*============================================================================*/ +/* Class: GtkTreeModel */ +/*============================================================================*/ + +::class GtkTreeModel public + +::METHOD init EXTERNAL "LIBRARY rexxgtk GrxTreeModelNewFromPtr" +::METHOD row_reference_new EXTERNAL "LIBRARY rexxgtk GrxTreeModelRowReferenceNew" +::METHOD get_n_columns EXTERNAL "LIBRARY rexxgtk GrxTreeModelGetNColumns" +::METHOD n_columns EXTERNAL "LIBRARY rexxgtk GrxTreeModelGetNColumns" +::METHOD get_column_type EXTERNAL "LIBRARY rexxgtk GrxTreeModelGetColumnType" +::METHOD column_type EXTERNAL "LIBRARY rexxgtk GrxTreeModelGetColumnType" + +::model create_tree_row_reference private +use strict arg ptr1, ptr2 +return GtkTreeRowReference~new(ptr1, ptr2) + + +/*============================================================================*/ +/* Class: GtkRowReference */ +/*============================================================================*/ + +::class GtkTreeRowReference public + +::METHOD init EXTERNAL "LIBRARY rexxgtk GrxTreeRowReferenceNewFromPtr" +::METHOD valid EXTERNAL "LIBRARY rexxgtk GrxTreeRowReferenceValid" + Modified: incubator/RexxGTK/4x/rexxgtk.cpp =================================================================== --- incubator/RexxGTK/4x/rexxgtk.cpp 2008-08-18 21:55:30 UTC (rev 3010) +++ incubator/RexxGTK/4x/rexxgtk.cpp 2008-08-19 02:29:27 UTC (rev 3011) @@ -796,6 +796,7 @@ REXX_METHOD(GrxTreeViewAppendColumn, GrxTreeViewAppendColumn), REXX_METHOD(GrxTreeViewInsertColumn, GrxTreeViewInsertColumn), REXX_METHOD(GrxTreeViewRemoveColumn, GrxTreeViewRemoveColumn), + REXX_METHOD(GrxTreeViewGetModel, GrxTreeViewGetModel), REXX_METHOD(GrxTreeViewSetModel, GrxTreeViewSetModel), REXX_METHOD(GrxTreeViewExpandAll, GrxTreeViewExpandAll), REXX_METHOD(GrxTreeViewSignalConnect, GrxTreeViewSignalConnect), @@ -820,6 +821,12 @@ REXX_METHOD(GrxTreePathGetDepth, GrxTreePathGetDepth), REXX_METHOD(GrxTreePathIsAncestor, GrxTreePathIsAncestor), REXX_METHOD(GrxTreePathIsDescendant, GrxTreePathIsDescendant), + REXX_METHOD(GrxTreeRowReferenceNewFromPtr, GrxTreeRowReferenceNewFromPtr), + REXX_METHOD(GrxTreeRowReferenceValid, GrxTreeRowReferenceValid), + REXX_METHOD(GrxTreeModelNewFromPtr, GrxTreeModelNewFromPtr), + REXX_METHOD(GrxTreeModelRowReferenceNew, GrxTreeModelRowReferenceNew), + REXX_METHOD(GrxTreeModelGetNColumns, GrxTreeModelGetNColumns), + REXX_METHOD(GrxTreeModelGetColumnType, GrxTreeModelGetColumnType), REXX_LAST_METHOD() }; Modified: incubator/RexxGTK/4x/rexxgtk.h =================================================================== --- incubator/RexxGTK/4x/rexxgtk.h 2008-08-18 21:55:30 UTC (rev 3010) +++ incubator/RexxGTK/4x/rexxgtk.h 2008-08-19 02:29:27 UTC (rev 3011) @@ -604,6 +604,7 @@ REXX_METHOD_PROTOTYPE(GrxTreeViewAppendColumn) REXX_METHOD_PROTOTYPE(GrxTreeViewInsertColumn) REXX_METHOD_PROTOTYPE(GrxTreeViewRemoveColumn) +REXX_METHOD_PROTOTYPE(GrxTreeViewGetModel) REXX_METHOD_PROTOTYPE(GrxTreeViewSetModel) REXX_METHOD_PROTOTYPE(GrxTreeViewExpandAll) REXX_METHOD_PROTOTYPE(GrxTreeViewSignalConnect) @@ -628,6 +629,12 @@ REXX_METHOD_PROTOTYPE(GrxTreePathGetDepth) REXX_METHOD_PROTOTYPE(GrxTreePathIsAncestor) REXX_METHOD_PROTOTYPE(GrxTreePathIsDescendant) +REXX_METHOD_PROTOTYPE(GrxTreeRowReferenceNewFromPtr) +REXX_METHOD_PROTOTYPE(GrxTreeRowReferenceValid) +REXX_METHOD_PROTOTYPE(GrxTreeModelNewFromPtr) +REXX_METHOD_PROTOTYPE(GrxTreeModelRowReferenceNew) +REXX_METHOD_PROTOTYPE(GrxTreeModelGetNColumns) +REXX_METHOD_PROTOTYPE(GrxTreeModelGetColumnType) #endif /* REXXGTK_H */ This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |
From: <bi...@us...> - 2008-08-18 21:55:23
|
Revision: 3010 http://oorexx.svn.sourceforge.net/oorexx/?rev=3010&view=rev Author: bigrixx Date: 2008-08-18 21:55:30 +0000 (Mon, 18 Aug 2008) Log Message: ----------- [ 1952525 ] Support ISO-8859-1 NOT character Modified Paths: -------------- main/trunk/interpreter/parser/Scanner.cpp Modified: main/trunk/interpreter/parser/Scanner.cpp =================================================================== --- main/trunk/interpreter/parser/Scanner.cpp 2008-08-18 21:43:03 UTC (rev 3009) +++ main/trunk/interpreter/parser/Scanner.cpp 2008-08-18 21:55:30 UTC (rev 3010) @@ -128,32 +128,32 @@ #ifdef EBCDIC // This table was built using the IBM-1047 code page. It should be // universal across all EBCDIC code pages! - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* */ - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* */ - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* */ - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* */ - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* */ - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* */ - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* */ - 0, 0, 0, 0, 0, 75, 0, 0, 0, 0, /* . */ - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* */ - 90, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* ! */ - 0, 0, 0, 0, 0, 0, 0, 0, 0, 109, /* _ */ - 0, 111, 0, 0, 0, 0, 0, 0, 0, 0, /* ? */ - 0, 0, 0, 0, 0, 0, 0, 0, 0, 129, /* a */ -130, 131, 132, 133, 134, 135, 136, 137, 0, 0, /* bcdefghi */ - 0, 0, 0, 0, 0, 145, 146, 147, 148, 149, /* jklmn */ -150, 151, 152, 153, 0, 0, 0, 0, 0, 0, /* opqr */ - 0, 0, 162, 163, 164, 165, 166, 167, 168, 169, /* stuvwxyz */ - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* */ - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* */ - 0, 0, 0, 193, 194, 195, 196, 197, 198, 199, /* ABCDEFG */ -200, 201, 0, 0, 0, 0, 0, 0, 0, 209, /* HI J */ -210, 211, 212, 213, 214, 215, 216, 217, 0, 0, /* KLMNOPQR */ - 0, 0, 0, 0, 0, 0, 226, 227, 228, 229, /* STUV */ -230, 231, 232, 233, 0, 0, 0, 0, 0, 0, /* WXYZ */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* */ + 0, 0, 0, 0, 0, 75, 0, 0, 0, 0, /* . */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* */ + 90, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* ! */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 109, /* _ */ + 0, 111, 0, 0, 0, 0, 0, 0, 0, 0, /* ? */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 129, /* a */ +130, 131, 132, 133, 134, 135, 136, 137, 0, 0, /* bcdefghi */ + 0, 0, 0, 0, 0, 145, 146, 147, 148, 149, /* jklmn */ +150, 151, 152, 153, 0, 0, 0, 0, 0, 0, /* opqr */ + 0, 0, 162, 163, 164, 165, 166, 167, 168, 169, /* stuvwxyz */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* */ + 0, 0, 0, 193, 194, 195, 196, 197, 198, 199, /* ABCDEFG */ +200, 201, 0, 0, 0, 0, 0, 0, 0, 209, /* HI J */ +210, 211, 212, 213, 214, 215, 216, 217, 0, 0, /* KLMNOPQR */ + 0, 0, 0, 0, 0, 0, 226, 227, 228, 229, /* STUV */ +230, 231, 232, 233, 0, 0, 0, 0, 0, 0, /* WXYZ */ 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, /* 0123456789 */ - 0, 0, 0, 0, 0, 0 /* */ + 0, 0, 0, 0, 0, 0 /* */ #else 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0 - 9 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 10 - 19 */ @@ -1322,7 +1322,9 @@ } break; - case (unsigned char)'\xAA': /* logical not (need unsigned cast) */ + // we accept either of these as alternatives + case (unsigned char)0xAA: /* logical not (need unsigned cast) */ + case (unsigned char)0xAC: /* logical not (need unsigned cast) */ /* next one an equal sign? */ if (this->nextSpecial('=', location)) { This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |
From: <bi...@us...> - 2008-08-18 21:42:59
|
Revision: 3009 http://oorexx.svn.sourceforge.net/oorexx/?rev=3009&view=rev Author: bigrixx Date: 2008-08-18 21:43:03 +0000 (Mon, 18 Aug 2008) Log Message: ----------- [ 1503291 ] Add QUALIFY BIF Modified Paths: -------------- main/trunk/interpreter/expression/BuiltinFunctions.cpp main/trunk/interpreter/parser/KeywordConstants.cpp main/trunk/interpreter/parser/Token.hpp main/trunk/interpreter/runtime/RexxConstants.hpp Modified: main/trunk/interpreter/expression/BuiltinFunctions.cpp =================================================================== --- main/trunk/interpreter/expression/BuiltinFunctions.cpp 2008-08-18 21:02:57 UTC (rev 3008) +++ main/trunk/interpreter/expression/BuiltinFunctions.cpp 2008-08-18 21:43:03 UTC (rev 3009) @@ -59,6 +59,7 @@ #include "ProtectedObject.hpp" #include "PackageManager.hpp" #include "SystemInterpreter.hpp" +#include "SysFileSystem.hpp" /* checks if pad is a single character string */ @@ -2607,6 +2608,25 @@ return SystemInterpreter::popEnvironment(context); } +#define QUALIFY_MIN 0 +#define QUALIFY_MAX 1 +#define QUALIFY_name 1 + +/** + * Qualify a stream name. + */ +BUILTIN(QUALIFY) +{ + check_args(QUALIFY); /* check on required number of args */ + RexxString *name = optional_string(QUALIFY, name); + + char qualified_name[SysFileSystem::MaximumFileNameLength]; + // qualifyStreamName will not expand if not a null string on entry. + qualified_name[0] = '\0'; + SysFileSystem::qualifyStreamName(name->getStringData(), qualified_name, sizeof(qualified_name)); + return new_string(qualified_name); +} + /* the following builtin function */ /* table must maintain the same order*/ /* as the builtin function codes used*/ @@ -2693,5 +2713,6 @@ &builtin_function_ENDLOCAL , &builtin_function_SETLOCAL , &builtin_function_QUEUEEXIT , + &builtin_function_QUALIFY , }; Modified: main/trunk/interpreter/parser/KeywordConstants.cpp =================================================================== --- main/trunk/interpreter/parser/KeywordConstants.cpp 2008-08-18 21:02:57 UTC (rev 3008) +++ main/trunk/interpreter/parser/KeywordConstants.cpp 2008-08-18 21:43:03 UTC (rev 3009) @@ -205,6 +205,7 @@ KeywordEntry(CHAR_MIN, BUILTIN_MIN), KeywordEntry(CHAR_OVERLAY, BUILTIN_OVERLAY), KeywordEntry(CHAR_POS, BUILTIN_POS), + KeywordEntry(CHAR_QUALIFY, BUILTIN_QUALIFY), KeywordEntry(CHAR_QUEUED, BUILTIN_QUEUED), KeywordEntry(CHAR_RANDOM, BUILTIN_RANDOM), KeywordEntry(CHAR_REVERSE, BUILTIN_REVERSE), @@ -285,6 +286,7 @@ KeywordEntry(CHAR_MIN, BUILTIN_MIN), KeywordEntry(CHAR_OVERLAY, BUILTIN_OVERLAY), KeywordEntry(CHAR_POS, BUILTIN_POS), + KeywordEntry(CHAR_QUALIFY, BUILTIN_QUALIFY), KeywordEntry(CHAR_QUEUED, BUILTIN_QUEUED), KeywordEntry(CHAR_RANDOM, BUILTIN_RANDOM), KeywordEntry(CHAR_REVERSE, BUILTIN_REVERSE), Modified: main/trunk/interpreter/parser/Token.hpp =================================================================== --- main/trunk/interpreter/parser/Token.hpp 2008-08-18 21:02:57 UTC (rev 3008) +++ main/trunk/interpreter/parser/Token.hpp 2008-08-18 21:43:03 UTC (rev 3009) @@ -375,6 +375,7 @@ #define BUILTIN_ENDLOCAL BUILTIN_RXFUNCQUERY + 1 #define BUILTIN_SETLOCAL BUILTIN_ENDLOCAL + 1 #define BUILTIN_QUEUEEXIT BUILTIN_SETLOCAL + 1 +#define BUILTIN_QUALIFY BUILTIN_QUEUEEXIT + 1 Modified: main/trunk/interpreter/runtime/RexxConstants.hpp =================================================================== --- main/trunk/interpreter/runtime/RexxConstants.hpp 2008-08-18 21:02:57 UTC (rev 3008) +++ main/trunk/interpreter/runtime/RexxConstants.hpp 2008-08-18 21:43:03 UTC (rev 3009) @@ -250,6 +250,7 @@ CHARCONSTANT(PUBLICCLASSES, "PUBLICCLASSES"); CHARCONSTANT(PUBLICROUTINES, "PUBLICROUTINES"); CHARCONSTANT(PUT, "PUT"); +CHARCONSTANT(QUALIFY, "QUALIFY"); CHARCONSTANT(QUEUE, "QUEUE"); CHARCONSTANT(QUEUEEXIT, "!QUEUEEXIT"); CHARCONSTANT(QUERYMIXINCLASS, "QUERYMIXINCLASS"); This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |
From: <bi...@us...> - 2008-08-18 21:02:56
|
Revision: 3008 http://oorexx.svn.sourceforge.net/oorexx/?rev=3008&view=rev Author: bigrixx Date: 2008-08-18 21:02:57 +0000 (Mon, 18 Aug 2008) Log Message: ----------- [ 2058055 ] Add delword to mutablebuffer Modified Paths: -------------- main/trunk/interpreter/classes/MutableBufferClass.cpp main/trunk/interpreter/classes/MutableBufferClass.hpp main/trunk/interpreter/execution/CPPCode.cpp main/trunk/interpreter/memory/Setup.cpp Modified: main/trunk/interpreter/classes/MutableBufferClass.cpp =================================================================== --- main/trunk/interpreter/classes/MutableBufferClass.cpp 2008-08-18 20:35:29 UTC (rev 3007) +++ main/trunk/interpreter/classes/MutableBufferClass.cpp 2008-08-18 21:02:57 UTC (rev 3008) @@ -1427,3 +1427,64 @@ { return StringUtil::caselessWordPos(getStringData(), getLength(), phrase, pstart); } + + +/** + * Perform a delword operation on a mutable buffer + * + * @param position The position to delete. + * @param plength The number of words to delete + * + * @return Always returns the target mutable buffer. + */ +RexxMutableBuffer *RexxMutableBuffer::delWord(RexxInteger *position, RexxInteger *plength) +{ + /* convert position to binary */ + size_t wordPos = positionArgument(position, ARG_ONE); + /* get num of words to delete, the */ + /* default is "a very large number" */ + size_t count = optionalLengthArgument(plength, MAXNUM, ARG_TWO); + + size_t length = getLength(); /* get string length */ + if (length == 0) /* null string? */ + { + return this; /* nothing to delete */ + } + if (count == 0) /* deleting zero words? */ + { + return this; /* also very easy */ + } + const char *word = getStringData(); /* point to the string */ + const char *nextSite = NULL; + /* get the first word */ + size_t wordLength = StringUtil::nextWord(&word, &length, &nextSite); + while (--wordPos > 0 && wordLength != 0) + { /* loop until we reach tArget */ + word = nextSite; /* copy the start pointer */ + /* get the next word */ + wordLength = StringUtil::nextWord(&word, &length, &nextSite); + } + if (wordPos != 0) /* run out of words first */ + { + return this; /* return the buffer unaltered */ + } + // get the deletion point as an offset + size_t deletePosition = word - this->getStringData(); + while (--count > 0 && wordLength != 0) + { /* loop until we reach tArget */ + word = nextSite; /* copy the start pointer */ + /* get the next word */ + wordLength = StringUtil::nextWord(&word, &length, &nextSite); + } + if (length != 0) /* didn't use up the string */ + { + StringUtil::skipBlanks(&nextSite, &length);/* skip over trailing blanks */ + } + + size_t gapSize = (nextSite - getStringData()) - deletePosition; + // close up the delete part + closeGap(deletePosition, gapSize, length); + // adjust for the deleted data + dataLength -= gapSize; + return this; +} Modified: main/trunk/interpreter/classes/MutableBufferClass.hpp =================================================================== --- main/trunk/interpreter/classes/MutableBufferClass.hpp 2008-08-18 20:35:29 UTC (rev 3007) +++ main/trunk/interpreter/classes/MutableBufferClass.hpp 2008-08-18 21:02:57 UTC (rev 3008) @@ -114,6 +114,7 @@ RexxInteger *words(); RexxInteger *wordPos(RexxString *, RexxInteger *); RexxInteger *caselessWordPos(RexxString *, RexxInteger *); + RexxMutableBuffer *delWord(RexxInteger *position, RexxInteger *plength); inline const char *getStringData() { return data->getData(); } inline size_t getLength() { return dataLength; } Modified: main/trunk/interpreter/execution/CPPCode.cpp =================================================================== --- main/trunk/interpreter/execution/CPPCode.cpp 2008-08-18 20:35:29 UTC (rev 3007) +++ main/trunk/interpreter/execution/CPPCode.cpp 2008-08-18 21:02:57 UTC (rev 3008) @@ -872,6 +872,7 @@ CPPM(RexxMutableBuffer::words), CPPM(RexxMutableBuffer::wordPos), CPPM(RexxMutableBuffer::caselessWordPos), +CPPM(RexxMutableBuffer::delWord), CPPM(RexxSupplier::available), /* Supplier methods */ CPPM(RexxSupplier::next), Modified: main/trunk/interpreter/memory/Setup.cpp =================================================================== --- main/trunk/interpreter/memory/Setup.cpp 2008-08-18 20:35:29 UTC (rev 3007) +++ main/trunk/interpreter/memory/Setup.cpp 2008-08-18 21:02:57 UTC (rev 3008) @@ -960,6 +960,7 @@ defineKernelMethod(CHAR_WORDS ,TheMutableBufferBehaviour, CPPM(RexxMutableBuffer::words), 0); defineKernelMethod(CHAR_WORDPOS ,TheMutableBufferBehaviour, CPPM(RexxMutableBuffer::wordPos), 2); defineKernelMethod(CHAR_CASELESSWORDPOS ,TheMutableBufferBehaviour, CPPM(RexxMutableBuffer::caselessWordPos), 2); + defineKernelMethod(CHAR_DELWORD ,TheMutableBufferBehaviour, CPPM(RexxMutableBuffer::delWord), 2); /* set the scope of the methods to */ /* this classes oref */ This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |
From: <bi...@us...> - 2008-08-18 20:35:29
|
Revision: 3007 http://oorexx.svn.sourceforge.net/oorexx/?rev=3007&view=rev Author: bigrixx Date: 2008-08-18 20:35:29 +0000 (Mon, 18 Aug 2008) Log Message: ----------- [ 2058010 ] add wordpos to mutablebuffer Modified Paths: -------------- main/trunk/interpreter/classes/MutableBufferClass.cpp main/trunk/interpreter/classes/MutableBufferClass.hpp main/trunk/interpreter/classes/StringClassWord.cpp main/trunk/interpreter/classes/StringUtil.cpp main/trunk/interpreter/classes/StringUtil.hpp main/trunk/interpreter/execution/CPPCode.cpp main/trunk/interpreter/memory/Setup.cpp Modified: main/trunk/interpreter/classes/MutableBufferClass.cpp =================================================================== --- main/trunk/interpreter/classes/MutableBufferClass.cpp 2008-08-18 20:13:42 UTC (rev 3006) +++ main/trunk/interpreter/classes/MutableBufferClass.cpp 2008-08-18 20:35:29 UTC (rev 3007) @@ -1399,3 +1399,31 @@ size_t tempCount = StringUtil::wordCount(this->getStringData(), this->getLength()); return new_integer(tempCount); } + + +/** + * Perform a wordpos search on a mutablebuffer object. + * + * @param phrase The search phrase + * @param pstart The starting search position. + * + * @return The index of the match location. + */ +RexxInteger *RexxMutableBuffer::wordPos(RexxString *phrase, RexxInteger *pstart) +{ + return StringUtil::wordPos(getStringData(), getLength(), phrase, pstart); +} + + +/** + * Perform a caseless wordpos search on a string object. + * + * @param phrase The search phrase + * @param pstart The starting search position. + * + * @return The index of the match location. + */ +RexxInteger *RexxMutableBuffer::caselessWordPos(RexxString *phrase, RexxInteger *pstart) +{ + return StringUtil::caselessWordPos(getStringData(), getLength(), phrase, pstart); +} Modified: main/trunk/interpreter/classes/MutableBufferClass.hpp =================================================================== --- main/trunk/interpreter/classes/MutableBufferClass.hpp 2008-08-18 20:13:42 UTC (rev 3006) +++ main/trunk/interpreter/classes/MutableBufferClass.hpp 2008-08-18 20:35:29 UTC (rev 3007) @@ -112,6 +112,8 @@ RexxInteger *wordIndex(RexxInteger *); RexxInteger *wordLength(RexxInteger *); RexxInteger *words(); + RexxInteger *wordPos(RexxString *, RexxInteger *); + RexxInteger *caselessWordPos(RexxString *, RexxInteger *); inline const char *getStringData() { return data->getData(); } inline size_t getLength() { return dataLength; } Modified: main/trunk/interpreter/classes/StringClassWord.cpp =================================================================== --- main/trunk/interpreter/classes/StringClassWord.cpp 2008-08-18 20:13:42 UTC (rev 3006) +++ main/trunk/interpreter/classes/StringClassWord.cpp 2008-08-18 20:35:29 UTC (rev 3007) @@ -262,240 +262,32 @@ return StringUtil::wordIndex(getStringData(), getLength(), position); } -/* the WORDPOS function */ -/******************************************************************************/ -/* Arguments: phrase of words to lookfor */ -/* which word to satrt looking at. */ -/* */ -/* Returned: position of 1st word in source matching phrase */ -/******************************************************************************/ -RexxInteger *RexxString::wordPos(RexxString *phrase, - RexxInteger *pstart) -{ - RexxInteger *Retval; /* return value */ - const char *Needle; /* start of needle string */ - const char *Haystack; /* current haystack positon */ - const char *NextNeedle; /* next search position */ - const char *NextHaystack; /* next search position */ - size_t Count; /* current haystack word pos */ - size_t NeedleWords; /* needle word count */ - size_t HaystackWords; /* haystack word count */ - size_t HaystackScanLength; /* length to scan */ - size_t NeedleScanLength; /* length of scan */ - size_t HaystackWordLength; /* haystack word length */ - size_t NeedleWordLength; /* needle word length */ - size_t SearchCount; /* possible searches to do */ - size_t FirstNeedle; /* length of first needle word */ - size_t NeedleLength; /* length of needle */ - size_t HaystackLength; /* length of haystack */ - const char *NeedlePosition; /* temporary pointers for */ - const char *HaystackPosition; /* the searches */ - const char *NextHaystackPtr; /* pointer to next word */ - const char *NextNeedlePtr; /* pointer to next word */ - size_t i; /* loop counter */ - phrase = stringArgument(phrase, ARG_ONE);/* get the phrase we are looking for */ - NeedleLength = phrase->getLength(); /* get the length also */ - /* get starting position, the default*/ - /* is the first word */ - Count = optionalPositionArgument(pstart, 1, ARG_TWO); - - Needle = phrase->getStringData(); /* get friendly pointer */ - Haystack = this->getStringData(); /* and the second also */ - HaystackLength = this->getLength(); /* get the haystack length */ - /* count the words in needle */ - NeedleWords = StringUtil::wordCount(Needle, NeedleLength); - /* and haystack */ - HaystackWords = StringUtil::wordCount(Haystack, HaystackLength); - /* if search string is longer */ - /* or no words in search */ - /* or count is longer than */ - /* haystack */ - if (NeedleWords > (HaystackWords - Count + 1) || - NeedleWords == 0 || - Count > HaystackWords) - { - Retval = IntegerZero; /* can't find anything, */ - } - else - { /* need to search */ - /* point at first word */ - HaystackWordLength = StringUtil::nextWord(&Haystack, &HaystackLength, &NextHaystack); - /* now skip over count-1 */ - for (i = Count - 1; i && HaystackWordLength != 0; i--) - { - Haystack = NextHaystack; /* step past current word */ - /* find the next word */ - HaystackWordLength = StringUtil::nextWord(&Haystack, &HaystackLength, &NextHaystack); - } - /* get number of searches */ - SearchCount = (HaystackWords - NeedleWords - Count) + 2; - /* position at first needle */ - FirstNeedle = StringUtil::nextWord(&Needle, &NeedleLength, &NextNeedle); - /* loop for the possible times */ - for (; SearchCount; SearchCount--) - { - NeedleWordLength = FirstNeedle; /* set the length */ - NeedlePosition = Needle; /* get the start of phrase */ - HaystackPosition = Haystack; /* and the target string loop */ - /* for needlewords */ - NextHaystackPtr = NextHaystack; /* copy nextword information */ - NextNeedlePtr = NextNeedle; - /* including the lengths */ - HaystackScanLength = HaystackLength; - NeedleScanLength = NeedleLength; - - for (i = NeedleWords; i; i--) - { /* possible times */ - - if (HaystackWordLength != /* if wrong length, then it */ - NeedleWordLength) /* can't be a match...just */ - { - break; /* leave the loop */ - } - - if (memcmp(NeedlePosition, /* if the two words don't */ - HaystackPosition, /* match, then no sense */ - NeedleWordLength)) /* checking the rest */ - { - break; /* get out fast. */ - } - - /* the last words matched, so */ - /* continue searching. */ - - /* set new search information */ - HaystackPosition = NextHaystackPtr; - NeedlePosition = NextNeedlePtr; - /* Scan off the next word */ - HaystackWordLength = StringUtil::nextWord(&HaystackPosition, - &HaystackScanLength, - &NextHaystackPtr); - /* repeat for the needle */ - NeedleWordLength = StringUtil::nextWord(&NeedlePosition, - &NeedleScanLength, - &NextNeedlePtr); - } - - if (!i) /* all words matched, we */ - { - break; /* found it */ - } - Haystack = NextHaystack; /* set the search position */ - /* step to next haytack pos */ - HaystackWordLength = StringUtil::nextWord(&Haystack, - &HaystackLength, - &NextHaystack); - Count++; /* remember the word position */ - } - - if (SearchCount != 0) /* if we haven't scanned the */ - { - /* entire string */ - Retval = new_integer(Count); /* return the position */ - } - else /* it wasn't found, just */ - { - Retval = IntegerZero; /* return a zero. */ - } - } - return Retval; /* return the position */ +/** + * Perform a wordpos search on a string object. + * + * @param phrase The search phrase + * @param pstart The starting search position. + * + * @return The index of the match location. + */ +RexxInteger *RexxString::wordPos(RexxString *phrase, RexxInteger *pstart) +{ + return StringUtil::wordPos(getStringData(), getLength(), phrase, pstart); } +/** + * Perform a caseless wordpos search on a string object. + * + * @param phrase The search phrase + * @param pstart The starting search position. + * + * @return The index of the match location. + */ RexxInteger *RexxString::caselessWordPos(RexxString *phrase, RexxInteger *pstart) { - phrase = stringArgument(phrase, ARG_ONE);/* get the phrase we are looking for */ - stringsize_t needleLength = phrase->getLength(); /* get the length also */ - /* get starting position, the default*/ - /* is the first word */ - stringsize_t count = optionalPositionArgument(pstart, 1, ARG_TWO); - - const char *needle = phrase->getStringData(); /* get friendly pointer */ - const char *haystack = this->getStringData(); /* and the second also */ - stringsize_t haystackLength = this->getLength(); /* get the haystack length */ - /* count the words in needle */ - stringsize_t needleWords = StringUtil::wordCount(needle, needleLength); - /* and haystack */ - stringsize_t haystackWords = StringUtil::wordCount(haystack, haystackLength); - /* if search string is longer */ - /* or no words in search */ - /* or count is longer than */ - /* haystack, this is a failure */ - if (needleWords > (haystackWords - count + 1) || needleWords == 0 || count > haystackWords) - { - return IntegerZero; - } - - const char *nextHaystack; - const char *nextNeedle; - /* point at first word */ - stringsize_t haystackWordLength = StringUtil::nextWord(&haystack, &haystackLength, &nextHaystack); - /* now skip over count-1 */ - for (stringsize_t i = count - 1; i && haystackWordLength != 0; i--) - { - haystack = nextHaystack; /* step past current word */ - /* find the next word */ - haystackWordLength = StringUtil::nextWord(&haystack, &haystackLength, &nextHaystack); - } - /* get number of searches */ - stringsize_t searchCount = (haystackWords - needleWords - count) + 2; - /* position at first needle */ - stringsize_t firstNeedle = StringUtil::nextWord(&needle, &needleLength, &nextNeedle); - /* loop for the possible times */ - for (; searchCount; searchCount--) - { - stringsize_t needleWordLength = firstNeedle; /* set the length */ - const char *needlePosition = needle; /* get the start of phrase */ - const char *haystackPosition = haystack; /* and the target string loop */ - /* for needlewords */ - const char *nextHaystackPtr = nextHaystack; /* copy nextword information */ - const char *nextNeedlePtr = nextNeedle; - /* including the lengths */ - stringsize_t haystackScanLength = haystackLength; - stringsize_t needleScanLength = needleLength; - - stringsize_t i; - - for (i = needleWords; i; i--) - { - // length mismatch, can't be a match - - if (haystackWordLength != needleWordLength) - { - break; - } - - // now compare the two words, using a caseless comparison - // if the words don't match, terminate now - if (StringUtil::caselessCompare(needlePosition, haystackPosition, needleWordLength)) - { - break; /* get out fast. */ - } - - /* the last words matched, so */ - /* continue searching. */ - - /* set new search information */ - haystackPosition = nextHaystackPtr; - needlePosition = nextNeedlePtr; - /* Scan off the next word */ - haystackWordLength = StringUtil::nextWord(&haystackPosition, &haystackScanLength, &nextHaystackPtr); - /* repeat for the needle */ - needleWordLength = StringUtil::nextWord(&needlePosition, &needleScanLength, &nextNeedlePtr); - } - - if (i == 0) /* all words matched, we */ - { - return new_integer(count); // return the position - } - haystack = nextHaystack; /* set the search position */ - /* step to next haytack pos */ - haystackWordLength = StringUtil::nextWord(&haystack, &haystackLength, &nextHaystack); - count++; /* remember the word position */ - } - - return IntegerZero; // not found + return StringUtil::caselessWordPos(getStringData(), getLength(), phrase, pstart); } /* the WORDS function */ Modified: main/trunk/interpreter/classes/StringUtil.cpp =================================================================== --- main/trunk/interpreter/classes/StringUtil.cpp 2008-08-18 20:13:42 UTC (rev 3006) +++ main/trunk/interpreter/classes/StringUtil.cpp 2008-08-18 20:35:29 UTC (rev 3007) @@ -1612,3 +1612,215 @@ } return new_integer(wordLength); /* return the word length */ } + + +/** + * Execute a wordpos search on a buffer of data. + * + * @param data the source data buffer. + * @param length the length of the buffer + * @param phrase the search phrase. + * @param pstart the starting position. + * + * @return the location of the start of the search phrase. + */ +RexxInteger *StringUtil::wordPos(const char *data, size_t length, RexxString *phrase, RexxInteger *pstart) +{ + phrase = stringArgument(phrase, ARG_ONE);/* get the phrase we are looking for */ + stringsize_t needleLength = phrase->getLength(); /* get the length also */ + /* get starting position, the default*/ + /* is the first word */ + stringsize_t count = optionalPositionArgument(pstart, 1, ARG_TWO); + + const char *needle = phrase->getStringData(); /* get friendly pointer */ + const char *haystack = data; /* and the second also */ + stringsize_t haystackLength = length; /* get the haystack length */ + /* count the words in needle */ + stringsize_t needleWords = wordCount(needle, needleLength); + /* and haystack */ + stringsize_t haystackWords = wordCount(haystack, haystackLength); + /* if search string is longer */ + /* or no words in search */ + /* or count is longer than */ + /* haystack, this is a failure */ + if (needleWords > (haystackWords - count + 1) || needleWords == 0 || count > haystackWords) + { + return IntegerZero; + } + + const char *nextHaystack; + const char *nextNeedle; + /* point at first word */ + stringsize_t haystackWordLength = nextWord(&haystack, &haystackLength, &nextHaystack); + /* now skip over count-1 */ + for (stringsize_t i = count - 1; i && haystackWordLength != 0; i--) + { + haystack = nextHaystack; /* step past current word */ + /* find the next word */ + haystackWordLength = nextWord(&haystack, &haystackLength, &nextHaystack); + } + /* get number of searches */ + stringsize_t searchCount = (haystackWords - needleWords - count) + 2; + /* position at first needle */ + stringsize_t firstNeedle = nextWord(&needle, &needleLength, &nextNeedle); + /* loop for the possible times */ + for (; searchCount; searchCount--) + { + stringsize_t needleWordLength = firstNeedle; /* set the length */ + const char *needlePosition = needle; /* get the start of phrase */ + const char *haystackPosition = haystack; /* and the target string loop */ + /* for needlewords */ + const char *nextHaystackPtr = nextHaystack; /* copy nextword information */ + const char *nextNeedlePtr = nextNeedle; + /* including the lengths */ + stringsize_t haystackScanLength = haystackLength; + stringsize_t needleScanLength = needleLength; + + stringsize_t i; + + for (i = needleWords; i; i--) + { + // length mismatch, can't be a match + + if (haystackWordLength != needleWordLength) + { + break; + } + + // now compare the two words, using a caseless comparison + // if the words don't match, terminate now + if (memcmp(needlePosition, haystackPosition, needleWordLength) != 0) + { + break; /* get out fast. */ + } + + /* the last words matched, so */ + /* continue searching. */ + + /* set new search information */ + haystackPosition = nextHaystackPtr; + needlePosition = nextNeedlePtr; + /* Scan off the next word */ + haystackWordLength = nextWord(&haystackPosition, &haystackScanLength, &nextHaystackPtr); + /* repeat for the needle */ + needleWordLength = nextWord(&needlePosition, &needleScanLength, &nextNeedlePtr); + } + + if (i == 0) /* all words matched, we */ + { + return new_integer(count); // return the position + } + haystack = nextHaystack; /* set the search position */ + /* step to next haytack pos */ + haystackWordLength = nextWord(&haystack, &haystackLength, &nextHaystack); + count++; /* remember the word position */ + } + + return IntegerZero; // not found +} + + +/** + * Execute a caseless wordpos search on a buffer of data. + * + * @param data the source data buffer. + * @param length the length of the buffer + * @param phrase the search phrase. + * @param pstart the starting position. + * + * @return the location of the start of the search phrase. + */ +RexxInteger *StringUtil::caselessWordPos(const char *data, size_t length, RexxString *phrase, RexxInteger *pstart) +{ + phrase = stringArgument(phrase, ARG_ONE);/* get the phrase we are looking for */ + stringsize_t needleLength = phrase->getLength(); /* get the length also */ + /* get starting position, the default*/ + /* is the first word */ + stringsize_t count = optionalPositionArgument(pstart, 1, ARG_TWO); + + const char *needle = phrase->getStringData(); /* get friendly pointer */ + const char *haystack = data; /* and the second also */ + stringsize_t haystackLength = length; /* get the haystack length */ + /* count the words in needle */ + stringsize_t needleWords = wordCount(needle, needleLength); + /* and haystack */ + stringsize_t haystackWords = wordCount(haystack, haystackLength); + /* if search string is longer */ + /* or no words in search */ + /* or count is longer than */ + /* haystack, this is a failure */ + if (needleWords > (haystackWords - count + 1) || needleWords == 0 || count > haystackWords) + { + return IntegerZero; + } + + const char *nextHaystack; + const char *nextNeedle; + /* point at first word */ + stringsize_t haystackWordLength = nextWord(&haystack, &haystackLength, &nextHaystack); + /* now skip over count-1 */ + for (stringsize_t i = count - 1; i && haystackWordLength != 0; i--) + { + haystack = nextHaystack; /* step past current word */ + /* find the next word */ + haystackWordLength = nextWord(&haystack, &haystackLength, &nextHaystack); + } + /* get number of searches */ + stringsize_t searchCount = (haystackWords - needleWords - count) + 2; + /* position at first needle */ + stringsize_t firstNeedle = nextWord(&needle, &needleLength, &nextNeedle); + /* loop for the possible times */ + for (; searchCount; searchCount--) + { + stringsize_t needleWordLength = firstNeedle; /* set the length */ + const char *needlePosition = needle; /* get the start of phrase */ + const char *haystackPosition = haystack; /* and the target string loop */ + /* for needlewords */ + const char *nextHaystackPtr = nextHaystack; /* copy nextword information */ + const char *nextNeedlePtr = nextNeedle; + /* including the lengths */ + stringsize_t haystackScanLength = haystackLength; + stringsize_t needleScanLength = needleLength; + + stringsize_t i; + + for (i = needleWords; i; i--) + { + // length mismatch, can't be a match + + if (haystackWordLength != needleWordLength) + { + break; + } + + // now compare the two words, using a caseless comparison + // if the words don't match, terminate now + if (caselessCompare(needlePosition, haystackPosition, needleWordLength)) + { + break; /* get out fast. */ + } + + /* the last words matched, so */ + /* continue searching. */ + + /* set new search information */ + haystackPosition = nextHaystackPtr; + needlePosition = nextNeedlePtr; + /* Scan off the next word */ + haystackWordLength = nextWord(&haystackPosition, &haystackScanLength, &nextHaystackPtr); + /* repeat for the needle */ + needleWordLength = nextWord(&needlePosition, &needleScanLength, &nextNeedlePtr); + } + + if (i == 0) /* all words matched, we */ + { + return new_integer(count); // return the position + } + haystack = nextHaystack; /* set the search position */ + /* step to next haytack pos */ + haystackWordLength = nextWord(&haystack, &haystackLength, &nextHaystack); + count++; /* remember the word position */ + } + + return IntegerZero; // not found +} Modified: main/trunk/interpreter/classes/StringUtil.hpp =================================================================== --- main/trunk/interpreter/classes/StringUtil.hpp 2008-08-18 20:13:42 UTC (rev 3006) +++ main/trunk/interpreter/classes/StringUtil.hpp 2008-08-18 20:35:29 UTC (rev 3007) @@ -85,6 +85,8 @@ static RexxString *word(const char *data, size_t length, RexxInteger *position); static RexxInteger *wordIndex(const char *data, size_t length, RexxInteger *position); static RexxInteger *wordLength(const char *data, size_t length, RexxInteger *position); + static RexxInteger *wordPos(const char *data, size_t length, RexxString *phrase, RexxInteger *pstart); + static RexxInteger *caselessWordPos(const char *data, size_t length, RexxString *phrase, RexxInteger *pstart); }; #endif Modified: main/trunk/interpreter/execution/CPPCode.cpp =================================================================== --- main/trunk/interpreter/execution/CPPCode.cpp 2008-08-18 20:13:42 UTC (rev 3006) +++ main/trunk/interpreter/execution/CPPCode.cpp 2008-08-18 20:35:29 UTC (rev 3007) @@ -870,6 +870,8 @@ CPPM(RexxMutableBuffer::wordIndex), CPPM(RexxMutableBuffer::wordLength), CPPM(RexxMutableBuffer::words), +CPPM(RexxMutableBuffer::wordPos), +CPPM(RexxMutableBuffer::caselessWordPos), CPPM(RexxSupplier::available), /* Supplier methods */ CPPM(RexxSupplier::next), Modified: main/trunk/interpreter/memory/Setup.cpp =================================================================== --- main/trunk/interpreter/memory/Setup.cpp 2008-08-18 20:13:42 UTC (rev 3006) +++ main/trunk/interpreter/memory/Setup.cpp 2008-08-18 20:35:29 UTC (rev 3007) @@ -958,6 +958,8 @@ defineKernelMethod(CHAR_WORDINDEX ,TheMutableBufferBehaviour, CPPM(RexxMutableBuffer::wordIndex), 1); defineKernelMethod(CHAR_WORDLENGTH ,TheMutableBufferBehaviour, CPPM(RexxMutableBuffer::wordLength), 1); defineKernelMethod(CHAR_WORDS ,TheMutableBufferBehaviour, CPPM(RexxMutableBuffer::words), 0); + defineKernelMethod(CHAR_WORDPOS ,TheMutableBufferBehaviour, CPPM(RexxMutableBuffer::wordPos), 2); + defineKernelMethod(CHAR_CASELESSWORDPOS ,TheMutableBufferBehaviour, CPPM(RexxMutableBuffer::caselessWordPos), 2); /* set the scope of the methods to */ /* this classes oref */ This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |
From: <mie...@us...> - 2008-08-18 20:13:36
|
Revision: 3006 http://oorexx.svn.sourceforge.net/oorexx/?rev=3006&view=rev Author: miesfeld Date: 2008-08-18 20:13:42 +0000 (Mon, 18 Aug 2008) Log Message: ----------- Update 'killer' to work with the 64-bit Windows build. The previous version could not find 64-bit processes to kill them. This version (compiled as a 32-bit program) should work unchanged on both 32-bit and 64-bit systems. Modified Paths: -------------- build-utilities/trunk/Makefile.win build-utilities/trunk/platform/windows/Release.notes build-utilities/trunk/platform/windows/killer.c Modified: build-utilities/trunk/Makefile.win =================================================================== --- build-utilities/trunk/Makefile.win 2008-08-18 20:11:27 UTC (rev 3005) +++ build-utilities/trunk/Makefile.win 2008-08-18 20:13:42 UTC (rev 3006) @@ -1,6 +1,6 @@ #------------------------------------------------------------------------------* # -# Copyright (c) 2007 Rexx Language Association. All rights reserved. +# Copyright (c) 2007-2008 Rexx Language Association. All rights reserved. # # This program and the accompanying materials are made available under # the terms of the Common Public License v1.0 which accompanies this @@ -48,11 +48,17 @@ all : $(OBJDIR) $(BINDIR) $(EXE_FILES) touchheaders : $(BINDIR)\stouch.exe $(ooRexx_SRCDIR) - $(BINDIR)\stouch $(ooRexx_SRCDIR)\kernel\messages\RexxErrorCodes.h - $(BINDIR)\stouch $(ooRexx_SRCDIR)\kernel\messages\RexxMessageNumbers.h - $(BINDIR)\stouch $(ooRexx_SRCDIR)\kernel\messages\RexxMessageTable.h - $(BINDIR)\stouch $(ooRexx_SRCDIR)\kernel\platform\windows\winmsgtb.rc - $(BINDIR)\stouch $(ooRexx_SRCDIR)\kernel\platform\unix\rexx.cat + $(BINDIR)\stouch $(ooRexx_SRCDIR)\interpreter\messages\RexxErrorCodes.h + $(BINDIR)\stouch $(ooRexx_SRCDIR)\interpreter\messages\RexxMessageNumbers.h + $(BINDIR)\stouch $(ooRexx_SRCDIR)\interpreter\messages\RexxMessageTable.h + $(BINDIR)\stouch $(ooRexx_SRCDIR)\interpreter\messages\DocErrorMessages.sgml + $(BINDIR)\stouch $(ooRexx_SRCDIR)\interpreter\messages\gencat.inp + $(BINDIR)\stouch $(ooRexx_SRCDIR)\interpreter\platform\windows\winmsgtb.rc + $(BINDIR)\stouch $(ooRexx_SRCDIR)\interpreter\platform\unix\rexx.cat + $(BINDIR)\stouch $(ooRexx_SRCDIR)\interpreter\behaviour\PrimitiveBehaviourNames.h + $(BINDIR)\stouch $(ooRexx_SRCDIR)\interpreter\behaviour\VirtualFunctionTable.cpp + $(BINDIR)\stouch $(ooRexx_SRCDIR)\interpreter\behaviour\ClassTypeCodes.h + $(BINDIR)\stouch $(ooRexx_SRCDIR)\api\oorexxerrors.h clean : @if exist $(OBJDIR) del $(OBJDIR)\*.obj 1>nul 2>&1 @@ -93,7 +99,7 @@ $(CC) $(CFLAGS) /O1 $(SRCDIR)\stouch.c $(BINDIR)\killer.exe : $(BINDIR) $(OBJDIR) $(OBJDIR)\killer.obj - $(LD) /SUBSYSTEM:Console /out:$(BINDIR)\killer.exe $(OBJDIR)\killer.obj psapi.lib + $(LD) /SUBSYSTEM:Console /out:$(BINDIR)\killer.exe $(OBJDIR)\killer.obj $(OBJDIR)\killer.obj : $(SRCDIR)\killer.c $(CC) $(CFLAGS) $(SRCDIR)\killer.c Modified: build-utilities/trunk/platform/windows/Release.notes =================================================================== --- build-utilities/trunk/platform/windows/Release.notes 2008-08-18 20:11:27 UTC (rev 3005) +++ build-utilities/trunk/platform/windows/Release.notes 2008-08-18 20:13:42 UTC (rev 3006) @@ -1,15 +1,18 @@ - Release Notes for 1.0.0 + Release Notes for 1.1.0 ======================= -This is the initial binary release of the ooRexx build-utilities package for +This is the binary release of the ooRexx build-utilities package for Windows. It contains executables to assist in the Windows build process of ooRexx. +The "killer" application in this release has been updated to kill 64-bit +applications on Windows 64-bit systems. This is the only changed from the +1.0.0 release. Two files are available, a regular .zip file and a self-extracting zip file: - ooRexx-build-utils-1.0.0-windows.zip - ooRexx-build-utils-1.0.0-windows.exe + ooRexx-build-utils-1.1.0-windows.zip + ooRexx-build-utils-1.1.0-windows.exe Installation ============ @@ -39,6 +42,9 @@ E:\interpreter>stouch kernel\messages\*.h +Note that the 1.1.0 release of stouch is exactly the same as the 1.0.0 +release. + killer.exe ---------- @@ -54,6 +60,10 @@ E:\killer rxapi +Note that the 1.1.0 release of killer is updated to work with the 64-bit +build of ooRexx. The 1.0.0 version will not kill 64-bit executables on +Windows. + Source ====== Modified: build-utilities/trunk/platform/windows/killer.c =================================================================== --- build-utilities/trunk/platform/windows/killer.c 2008-08-18 20:11:27 UTC (rev 3005) +++ build-utilities/trunk/platform/windows/killer.c 2008-08-18 20:13:42 UTC (rev 3006) @@ -33,88 +33,117 @@ /* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ /* */ /*----------------------------------------------------------------------------*/ + /* - * Program to kill a named process under Windows - * Only argument: process name + * Program to kill a named process under Windows. The compiled program + * (compiled as 32-bit) should also work on 64-bit Windows. + * + * Only argument: The process name. This can include, or not, the ".exe" + * extension. */ + #include <windows.h> #include <stdio.h> -#include "psapi.h" +#include <tlhelp32.h> +/* Prototypes */ +void tryToKill(PROCESSENTRY32 *pPe32); +void printError(const char *msg); + int main( int argc, char *argv[] ) { - // Find all processes + char szArgName[MAX_PATH] = ""; + BOOL fFound = FALSE; + char *pszExt; + HANDLE hAllProcesses; + PROCESSENTRY32 pe32; - DWORD aProcesses[4096], cbNeeded, cProcesses, processID, cLength; - HANDLE hProcess; - char szProcessName[MAX_PATH] = ""; - char szArgName[MAX_PATH] = ""; - unsigned int i; - BOOL fFound = FALSE; - char *pszExt; - if ( argc != 2 ) { - fprintf( stderr, "No process name supplied\n" ); - return 1; + fprintf(stderr, "No process name supplied\n"); + return 1; } // Support either kill or taskkill syntax pszExt = strrchr( argv[1], '.' ); - if ( pszExt && (stricmp( pszExt, ".exe" ) == 0) ) - sprintf( szArgName, "%s", argv[1] ); + if ( pszExt && (stricmp(pszExt, ".exe") == 0) ) + { + _snprintf(szArgName, sizeof(szArgName), "%s", argv[1]); + } else - sprintf( szArgName, "%s.exe", argv[1] ); + { + _snprintf(szArgName, sizeof(szArgName), "%s.exe", argv[1] ); + } - if ( !EnumProcesses( aProcesses, sizeof(aProcesses), &cbNeeded ) ) + // Get a snapshot of all processes running on the system. + pe32.dwSize = sizeof(PROCESSENTRY32); + hAllProcesses = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0); + if( hAllProcesses == INVALID_HANDLE_VALUE ) { - CHAR LastError[256]; - ULONG last_error = GetLastError(); - FormatMessage( FORMAT_MESSAGE_FROM_SYSTEM, NULL, GetLastError(), MAKELANGID( LANG_NEUTRAL, SUBLANG_DEFAULT), LastError, 256, NULL ) ; - fprintf( stderr, "No processes found. %s\n", LastError ); - return 1; + printError("Creating process list"); + return 1; } - // How many processes? + // Get the first process entry. + if( ! Process32First(hAllProcesses, &pe32) ) + { + printError("Process32First()"); + CloseHandle(hAllProcesses); + return 1; + } - cProcesses = cbNeeded / sizeof(DWORD); + // Look at each process until we find the one we want. Then try to kill it. + do + { + if ( stricmp(pe32.szExeFile, szArgName) == 0 ) + { + fFound = TRUE; + tryToKill(&pe32); + break; + } + } while( Process32Next(hAllProcesses, &pe32) ); - // Find our process and kill it + CloseHandle(hAllProcesses); - for ( i = 0; i < cProcesses; i++ ) + if ( ! fFound ) { - // Get a handle to the process. - hProcess = OpenProcess( PROCESS_ALL_ACCESS, FALSE, aProcesses[i] ); - - // Get the process name. - if ( hProcess ) - { - HMODULE hMod; - - if ( EnumProcessModules( hProcess, &hMod, sizeof(hMod), &cbNeeded) ) - { - GetModuleBaseName( hProcess, hMod, szProcessName, sizeof(szProcessName) ); - if ( stricmp( szProcessName, szArgName ) == 0 ) - { - fFound = TRUE; - if ( TerminateProcess( hProcess, 0 ) ) - { - printf( "%s (Process ID: %u) killed successfully\n", szProcessName, aProcesses[i] ); - } - else - { - CHAR LastError[256]; - ULONG last_error = GetLastError(); - FormatMessage( FORMAT_MESSAGE_FROM_SYSTEM, NULL, GetLastError(), MAKELANGID( LANG_NEUTRAL, SUBLANG_DEFAULT), LastError, 256, NULL ) ; - printf( "%s (Process ID: %u) NOT killed. %s\n", szProcessName, aProcesses[i], LastError ); - } - } - } - CloseHandle( hProcess ); - } + printf("The process \"%s\" was not found.\n", szArgName); } - if ( ! fFound ) - printf( "The process \"%s\" was not found.\n", szArgName ); return 0; } + +void tryToKill(PROCESSENTRY32 *pPe32) +{ + HANDLE hProcess; + + hProcess = OpenProcess(PROCESS_ALL_ACCESS, FALSE, pPe32->th32ProcessID); + if( hProcess == NULL ) + { + printError("OpenProcess()"); + } + else + { + if ( TerminateProcess(hProcess, 0) ) + { + printf("%s (process ID: %u) killed successfully\n", pPe32->szExeFile, pPe32->th32ProcessID); + } + else + { + TCHAR msg[64]; + _snprintf(msg, sizeof(msg), "Killing %s (process ID: %u)", pPe32->szExeFile, pPe32->th32ProcessID); + printError(msg); + } + CloseHandle(hProcess); + } +} + +void printError(const char *msg) +{ + TCHAR buf[256]; + DWORD err = GetLastError(); + + FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM, NULL, err, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), + buf, 256, NULL); + fprintf(stderr, "%s failed with error %d (%s)\n", msg, err, buf); +} This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |
From: <bi...@us...> - 2008-08-18 20:11:23
|
Revision: 3005 http://oorexx.svn.sourceforge.net/oorexx/?rev=3005&view=rev Author: bigrixx Date: 2008-08-18 20:11:27 +0000 (Mon, 18 Aug 2008) Log Message: ----------- [ 2058023 ] add words() to mutable buffer Modified Paths: -------------- main/trunk/interpreter/classes/MutableBufferClass.cpp main/trunk/interpreter/classes/MutableBufferClass.hpp main/trunk/interpreter/execution/CPPCode.cpp main/trunk/interpreter/memory/Setup.cpp Modified: main/trunk/interpreter/classes/MutableBufferClass.cpp =================================================================== --- main/trunk/interpreter/classes/MutableBufferClass.cpp 2008-08-18 20:06:09 UTC (rev 3004) +++ main/trunk/interpreter/classes/MutableBufferClass.cpp 2008-08-18 20:11:27 UTC (rev 3005) @@ -1388,3 +1388,14 @@ { return StringUtil::wordLength(getStringData(), getLength(), position); } + +/** + * Return the count of words in the buffer. + * + * @return The buffer word count. + */ +RexxInteger *RexxMutableBuffer::words() +{ + size_t tempCount = StringUtil::wordCount(this->getStringData(), this->getLength()); + return new_integer(tempCount); +} Modified: main/trunk/interpreter/classes/MutableBufferClass.hpp =================================================================== --- main/trunk/interpreter/classes/MutableBufferClass.hpp 2008-08-18 20:06:09 UTC (rev 3004) +++ main/trunk/interpreter/classes/MutableBufferClass.hpp 2008-08-18 20:11:27 UTC (rev 3005) @@ -111,6 +111,7 @@ RexxString *word(RexxInteger *); RexxInteger *wordIndex(RexxInteger *); RexxInteger *wordLength(RexxInteger *); + RexxInteger *words(); inline const char *getStringData() { return data->getData(); } inline size_t getLength() { return dataLength; } Modified: main/trunk/interpreter/execution/CPPCode.cpp =================================================================== --- main/trunk/interpreter/execution/CPPCode.cpp 2008-08-18 20:06:09 UTC (rev 3004) +++ main/trunk/interpreter/execution/CPPCode.cpp 2008-08-18 20:11:27 UTC (rev 3005) @@ -869,6 +869,7 @@ CPPM(RexxMutableBuffer::word), CPPM(RexxMutableBuffer::wordIndex), CPPM(RexxMutableBuffer::wordLength), +CPPM(RexxMutableBuffer::words), CPPM(RexxSupplier::available), /* Supplier methods */ CPPM(RexxSupplier::next), Modified: main/trunk/interpreter/memory/Setup.cpp =================================================================== --- main/trunk/interpreter/memory/Setup.cpp 2008-08-18 20:06:09 UTC (rev 3004) +++ main/trunk/interpreter/memory/Setup.cpp 2008-08-18 20:11:27 UTC (rev 3005) @@ -957,6 +957,7 @@ defineKernelMethod(CHAR_WORD ,TheMutableBufferBehaviour, CPPM(RexxMutableBuffer::word), 1); defineKernelMethod(CHAR_WORDINDEX ,TheMutableBufferBehaviour, CPPM(RexxMutableBuffer::wordIndex), 1); defineKernelMethod(CHAR_WORDLENGTH ,TheMutableBufferBehaviour, CPPM(RexxMutableBuffer::wordLength), 1); + defineKernelMethod(CHAR_WORDS ,TheMutableBufferBehaviour, CPPM(RexxMutableBuffer::words), 0); /* set the scope of the methods to */ /* this classes oref */ This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |
From: <bi...@us...> - 2008-08-18 20:06:08
|
Revision: 3004 http://oorexx.svn.sourceforge.net/oorexx/?rev=3004&view=rev Author: bigrixx Date: 2008-08-18 20:06:09 +0000 (Mon, 18 Aug 2008) Log Message: ----------- [ 2058018 ] add wordlength() to mutablebuffer Modified Paths: -------------- main/trunk/interpreter/classes/MutableBufferClass.cpp main/trunk/interpreter/classes/MutableBufferClass.hpp main/trunk/interpreter/classes/StringClassWord.cpp main/trunk/interpreter/classes/StringUtil.cpp main/trunk/interpreter/classes/StringUtil.hpp main/trunk/interpreter/execution/CPPCode.cpp main/trunk/interpreter/memory/Setup.cpp Modified: main/trunk/interpreter/classes/MutableBufferClass.cpp =================================================================== --- main/trunk/interpreter/classes/MutableBufferClass.cpp 2008-08-18 19:40:45 UTC (rev 3003) +++ main/trunk/interpreter/classes/MutableBufferClass.cpp 2008-08-18 20:06:09 UTC (rev 3004) @@ -1367,9 +1367,24 @@ * * @param position The target word position. * - * @return The extracted word, as a string. + * @return The position of the target word. */ RexxInteger *RexxMutableBuffer::wordIndex(RexxInteger *position) { return StringUtil::wordIndex(getStringData(), getLength(), position); } + + +/** + * return the length of a given word position in a mutable + * buffer + * + * + * @param position The target word position. + * + * @return The length of the target word. + */ +RexxInteger *RexxMutableBuffer::wordLength(RexxInteger *position) +{ + return StringUtil::wordLength(getStringData(), getLength(), position); +} Modified: main/trunk/interpreter/classes/MutableBufferClass.hpp =================================================================== --- main/trunk/interpreter/classes/MutableBufferClass.hpp 2008-08-18 19:40:45 UTC (rev 3003) +++ main/trunk/interpreter/classes/MutableBufferClass.hpp 2008-08-18 20:06:09 UTC (rev 3004) @@ -110,6 +110,7 @@ RexxString *subWord(RexxInteger *, RexxInteger *); RexxString *word(RexxInteger *); RexxInteger *wordIndex(RexxInteger *); + RexxInteger *wordLength(RexxInteger *); inline const char *getStringData() { return data->getData(); } inline size_t getLength() { return dataLength; } Modified: main/trunk/interpreter/classes/StringClassWord.cpp =================================================================== --- main/trunk/interpreter/classes/StringClassWord.cpp 2008-08-18 19:40:45 UTC (rev 3003) +++ main/trunk/interpreter/classes/StringClassWord.cpp 2008-08-18 20:06:09 UTC (rev 3004) @@ -259,26 +259,7 @@ /******************************************************************************/ RexxInteger *RexxString::wordLength(RexxInteger *position) { - const char *Word; /* current word pointer */ - const char *NextSite; /* next word */ - size_t Length; /* string length */ - size_t WordLength; /* word length */ - size_t WordPos; /* desired word position */ - - Length = this->getLength(); /* get the string length */ - /* convert count to binary */ - WordPos = positionArgument(position , ARG_ONE); - Word = this->getStringData(); /* point to word data */ - - /* get the first word */ - WordLength = StringUtil::nextWord(&Word, &Length, &NextSite); - while (--WordPos && WordLength) - { /* loop until we reach target */ - Word = NextSite; /* copy the start pointer */ - /* get the next word */ - WordLength = StringUtil::nextWord(&Word, &Length, &NextSite); - } - return new_integer(WordLength); /* return the word length */ + return StringUtil::wordIndex(getStringData(), getLength(), position); } /* the WORDPOS function */ Modified: main/trunk/interpreter/classes/StringUtil.cpp =================================================================== --- main/trunk/interpreter/classes/StringUtil.cpp 2008-08-18 19:40:45 UTC (rev 3003) +++ main/trunk/interpreter/classes/StringUtil.cpp 2008-08-18 20:06:09 UTC (rev 3004) @@ -1583,3 +1583,32 @@ } return new_integer(word - data + 1); } + + +/** + * Return the length of the word located at a given index. + * + * @param data The data containing the word list. + * @param length The length of the data buffer + * @param position The target word position. + * + * @return The length of the given word at the target index. Returns + * 0 if no word is found. + */ +RexxInteger *StringUtil::wordLength(const char *data, size_t length, RexxInteger *position) +{ + /* convert count to binary */ + size_t wordPos = positionArgument(position , ARG_ONE); + const char *word = data; /* point to word data */ + const char *nextSite = NULL; + + /* get the first word */ + size_t wordLength = nextWord(&word, &length, &nextSite); + while (--wordPos > 0 && wordLength != 0) + { /* loop until we reach target */ + word = nextSite; /* copy the start pointer */ + /* get the next word */ + wordLength = nextWord(&word, &length, &nextSite); + } + return new_integer(wordLength); /* return the word length */ +} Modified: main/trunk/interpreter/classes/StringUtil.hpp =================================================================== --- main/trunk/interpreter/classes/StringUtil.hpp 2008-08-18 19:40:45 UTC (rev 3003) +++ main/trunk/interpreter/classes/StringUtil.hpp 2008-08-18 20:06:09 UTC (rev 3004) @@ -84,6 +84,7 @@ static RexxString *subWord(const char *data, size_t length, RexxInteger *position, RexxInteger *plength); static RexxString *word(const char *data, size_t length, RexxInteger *position); static RexxInteger *wordIndex(const char *data, size_t length, RexxInteger *position); + static RexxInteger *wordLength(const char *data, size_t length, RexxInteger *position); }; #endif Modified: main/trunk/interpreter/execution/CPPCode.cpp =================================================================== --- main/trunk/interpreter/execution/CPPCode.cpp 2008-08-18 19:40:45 UTC (rev 3003) +++ main/trunk/interpreter/execution/CPPCode.cpp 2008-08-18 20:06:09 UTC (rev 3004) @@ -868,6 +868,7 @@ CPPM(RexxMutableBuffer::subWord), CPPM(RexxMutableBuffer::word), CPPM(RexxMutableBuffer::wordIndex), +CPPM(RexxMutableBuffer::wordLength), CPPM(RexxSupplier::available), /* Supplier methods */ CPPM(RexxSupplier::next), Modified: main/trunk/interpreter/memory/Setup.cpp =================================================================== --- main/trunk/interpreter/memory/Setup.cpp 2008-08-18 19:40:45 UTC (rev 3003) +++ main/trunk/interpreter/memory/Setup.cpp 2008-08-18 20:06:09 UTC (rev 3004) @@ -956,6 +956,7 @@ defineKernelMethod(CHAR_SUBWORD ,TheMutableBufferBehaviour, CPPM(RexxMutableBuffer::subWord), 2); defineKernelMethod(CHAR_WORD ,TheMutableBufferBehaviour, CPPM(RexxMutableBuffer::word), 1); defineKernelMethod(CHAR_WORDINDEX ,TheMutableBufferBehaviour, CPPM(RexxMutableBuffer::wordIndex), 1); + defineKernelMethod(CHAR_WORDLENGTH ,TheMutableBufferBehaviour, CPPM(RexxMutableBuffer::wordLength), 1); /* set the scope of the methods to */ /* this classes oref */ This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |
From: <bi...@us...> - 2008-08-18 19:40:45
|
Revision: 3003 http://oorexx.svn.sourceforge.net/oorexx/?rev=3003&view=rev Author: bigrixx Date: 2008-08-18 19:40:45 +0000 (Mon, 18 Aug 2008) Log Message: ----------- [ 2058012 ] add wordindex to mutablebuffer Modified Paths: -------------- main/trunk/interpreter/classes/MutableBufferClass.cpp main/trunk/interpreter/classes/MutableBufferClass.hpp main/trunk/interpreter/classes/StringClassWord.cpp main/trunk/interpreter/classes/StringUtil.cpp main/trunk/interpreter/classes/StringUtil.hpp main/trunk/interpreter/execution/CPPCode.cpp main/trunk/interpreter/memory/Setup.cpp Modified: main/trunk/interpreter/classes/MutableBufferClass.cpp =================================================================== --- main/trunk/interpreter/classes/MutableBufferClass.cpp 2008-08-18 19:24:40 UTC (rev 3002) +++ main/trunk/interpreter/classes/MutableBufferClass.cpp 2008-08-18 19:40:45 UTC (rev 3003) @@ -1359,3 +1359,17 @@ { return StringUtil::word(getStringData(), getLength(), position); } + + +/** + * return the index of a given word position in a mutable buffer + * + * + * @param position The target word position. + * + * @return The extracted word, as a string. + */ +RexxInteger *RexxMutableBuffer::wordIndex(RexxInteger *position) +{ + return StringUtil::wordIndex(getStringData(), getLength(), position); +} Modified: main/trunk/interpreter/classes/MutableBufferClass.hpp =================================================================== --- main/trunk/interpreter/classes/MutableBufferClass.hpp 2008-08-18 19:24:40 UTC (rev 3002) +++ main/trunk/interpreter/classes/MutableBufferClass.hpp 2008-08-18 19:40:45 UTC (rev 3003) @@ -109,6 +109,7 @@ RexxInteger *verify(RexxString *, RexxString *, RexxInteger *, RexxInteger *); RexxString *subWord(RexxInteger *, RexxInteger *); RexxString *word(RexxInteger *); + RexxInteger *wordIndex(RexxInteger *); inline const char *getStringData() { return data->getData(); } inline size_t getLength() { return dataLength; } Modified: main/trunk/interpreter/classes/StringClassWord.cpp =================================================================== --- main/trunk/interpreter/classes/StringClassWord.cpp 2008-08-18 19:24:40 UTC (rev 3002) +++ main/trunk/interpreter/classes/StringClassWord.cpp 2008-08-18 19:40:45 UTC (rev 3003) @@ -248,37 +248,7 @@ /******************************************************************************/ RexxInteger *RexxString::wordIndex(RexxInteger *position) { - const char *Word; /* current word pointer */ - const char *NextSite; /* next word */ - size_t Length; /* string length */ - size_t WordLength; /* word length */ - size_t WordPos; /* desired word position */ - RexxInteger *Retval; /* return value */ - size_t tempIndex; - - Length = this->getLength(); /* get the string length */ - /* convert count to binary */ - WordPos = positionArgument(position, ARG_ONE); - Word = this->getStringData(); /* point to word data */ - - /* get the first word */ - WordLength = StringUtil::nextWord(&Word, &Length, &NextSite); - while (--WordPos && WordLength) - { /* loop until we reach target */ - Word = NextSite; /* copy the start pointer */ - /* get the next word */ - WordLength = StringUtil::nextWord(&Word, &Length, &NextSite); - } - if (WordLength == 0) /* ran out of string */ - { - Retval = IntegerZero; /* no index */ - } - else - { /* calc the word index */ - tempIndex = Word - this->getStringData() + 1; - Retval = new_integer(tempIndex); - } - return Retval; /* return appopriate position */ + return StringUtil::wordIndex(getStringData(), getLength(), position); } /* the WORDLENGTH function */ Modified: main/trunk/interpreter/classes/StringUtil.cpp =================================================================== --- main/trunk/interpreter/classes/StringUtil.cpp 2008-08-18 19:24:40 UTC (rev 3002) +++ main/trunk/interpreter/classes/StringUtil.cpp 2008-08-18 19:40:45 UTC (rev 3003) @@ -1550,3 +1550,36 @@ } return OREF_NULLSTRING; /* no word, return a null */ } + + +/** + * Return the index position for a given word + * + * @param data The data containing the words + * @param length The length of the data buffer + * @param position The target word position + * + * @return The offset of the start of the indicated word. + */ +RexxInteger *StringUtil::wordIndex(const char *data, size_t length, RexxInteger *position) +{ + /* convert count to binary */ + size_t wordPos = positionArgument(position, ARG_ONE); + const char *word = data; /* point to word data */ + const char *nextSite = NULL; + + /* get the first word */ + size_t wordLength = nextWord(&word, &length, &nextSite); + while (--wordPos > 0 && wordLength != 0) + { /* loop until we reach target */ + word = nextSite; /* copy the start pointer */ + /* get the next word */ + wordLength = nextWord(&word, &length, &nextSite); + } + + if (wordLength == 0) /* ran out of string */ + { + return IntegerZero; /* no index */ + } + return new_integer(word - data + 1); +} Modified: main/trunk/interpreter/classes/StringUtil.hpp =================================================================== --- main/trunk/interpreter/classes/StringUtil.hpp 2008-08-18 19:24:40 UTC (rev 3002) +++ main/trunk/interpreter/classes/StringUtil.hpp 2008-08-18 19:40:45 UTC (rev 3003) @@ -83,6 +83,7 @@ static RexxInteger *verify(const char *data, size_t stringLen, RexxString *ref, RexxString *option, RexxInteger *_start, RexxInteger *range); static RexxString *subWord(const char *data, size_t length, RexxInteger *position, RexxInteger *plength); static RexxString *word(const char *data, size_t length, RexxInteger *position); + static RexxInteger *wordIndex(const char *data, size_t length, RexxInteger *position); }; #endif Modified: main/trunk/interpreter/execution/CPPCode.cpp =================================================================== --- main/trunk/interpreter/execution/CPPCode.cpp 2008-08-18 19:24:40 UTC (rev 3002) +++ main/trunk/interpreter/execution/CPPCode.cpp 2008-08-18 19:40:45 UTC (rev 3003) @@ -867,6 +867,7 @@ CPPM(RexxMutableBuffer::verify), CPPM(RexxMutableBuffer::subWord), CPPM(RexxMutableBuffer::word), +CPPM(RexxMutableBuffer::wordIndex), CPPM(RexxSupplier::available), /* Supplier methods */ CPPM(RexxSupplier::next), Modified: main/trunk/interpreter/memory/Setup.cpp =================================================================== --- main/trunk/interpreter/memory/Setup.cpp 2008-08-18 19:24:40 UTC (rev 3002) +++ main/trunk/interpreter/memory/Setup.cpp 2008-08-18 19:40:45 UTC (rev 3003) @@ -955,6 +955,7 @@ defineKernelMethod(CHAR_VERIFY ,TheMutableBufferBehaviour, CPPM(RexxMutableBuffer::verify), 4); defineKernelMethod(CHAR_SUBWORD ,TheMutableBufferBehaviour, CPPM(RexxMutableBuffer::subWord), 2); defineKernelMethod(CHAR_WORD ,TheMutableBufferBehaviour, CPPM(RexxMutableBuffer::word), 1); + defineKernelMethod(CHAR_WORDINDEX ,TheMutableBufferBehaviour, CPPM(RexxMutableBuffer::wordIndex), 1); /* set the scope of the methods to */ /* this classes oref */ This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |
From: <bi...@us...> - 2008-08-18 19:24:42
|
Revision: 3002 http://oorexx.svn.sourceforge.net/oorexx/?rev=3002&view=rev Author: bigrixx Date: 2008-08-18 19:24:40 +0000 (Mon, 18 Aug 2008) Log Message: ----------- [ 2058022 ] add word() to mutablebuffer Modified Paths: -------------- main/trunk/interpreter/classes/MutableBufferClass.cpp main/trunk/interpreter/classes/MutableBufferClass.hpp main/trunk/interpreter/classes/StringClassWord.cpp main/trunk/interpreter/classes/StringUtil.cpp main/trunk/interpreter/classes/StringUtil.hpp main/trunk/interpreter/execution/CPPCode.cpp main/trunk/interpreter/memory/Setup.cpp Modified: main/trunk/interpreter/classes/MutableBufferClass.cpp =================================================================== --- main/trunk/interpreter/classes/MutableBufferClass.cpp 2008-08-18 18:59:58 UTC (rev 3001) +++ main/trunk/interpreter/classes/MutableBufferClass.cpp 2008-08-18 19:24:40 UTC (rev 3002) @@ -1346,3 +1346,16 @@ { return StringUtil::subWord(getStringData(), getLength(), position, plength); } + + +/** + * Extract a given word from a mutable buffer. + * + * @param position The target word position. + * + * @return The extracted word, as a string. + */ +RexxString *RexxMutableBuffer::word(RexxInteger *position) +{ + return StringUtil::word(getStringData(), getLength(), position); +} Modified: main/trunk/interpreter/classes/MutableBufferClass.hpp =================================================================== --- main/trunk/interpreter/classes/MutableBufferClass.hpp 2008-08-18 18:59:58 UTC (rev 3001) +++ main/trunk/interpreter/classes/MutableBufferClass.hpp 2008-08-18 19:24:40 UTC (rev 3002) @@ -108,6 +108,7 @@ RexxInteger *caselessMatchChar(RexxInteger *position_, RexxString *matchSet); RexxInteger *verify(RexxString *, RexxString *, RexxInteger *, RexxInteger *); RexxString *subWord(RexxInteger *, RexxInteger *); + RexxString *word(RexxInteger *); inline const char *getStringData() { return data->getData(); } inline size_t getLength() { return dataLength; } Modified: main/trunk/interpreter/classes/StringClassWord.cpp =================================================================== --- main/trunk/interpreter/classes/StringClassWord.cpp 2008-08-18 18:59:58 UTC (rev 3001) +++ main/trunk/interpreter/classes/StringClassWord.cpp 2008-08-18 19:24:40 UTC (rev 3002) @@ -237,43 +237,7 @@ /******************************************************************************/ RexxString *RexxString::word(RexxInteger *position) { - const char *Word; /* current word pointer */ - const char *NextSite; /* next word */ - size_t WordPos; /* needed word position */ - size_t Length; /* remaining length */ - size_t WordLength; /* word size */ - RexxString *Retval; /* return value */ - - /* convert position to binary */ - WordPos = positionArgument(position, ARG_ONE); - - Length = this->getLength(); /* get Argument length */ - if (Length == 0) /* null string? */ - { - Retval = OREF_NULLSTRING; /* result is null also */ - } - else - { - Word = this->getStringData(); /* point to the string */ - /* get the first word */ - WordLength = StringUtil::nextWord(&Word, &Length, &NextSite); - while (--WordPos && WordLength) - { /* loop until we reach target */ - Word = NextSite; /* copy the start pointer */ - /* get the next word */ - WordLength = StringUtil::nextWord(&Word, &Length, &NextSite); - } - if (WordLength) /* have a word */ - { - /* extract the string */ - Retval = (RexxString *)new_string(Word, WordLength); - } - else - { - Retval = OREF_NULLSTRING; /* no word, return a null */ - } - } - return Retval; /* return extracted string */ + return StringUtil::word(getStringData(), getLength(), position); } /* the WORDINDEX function */ Modified: main/trunk/interpreter/classes/StringUtil.cpp =================================================================== --- main/trunk/interpreter/classes/StringUtil.cpp 2008-08-18 18:59:58 UTC (rev 3001) +++ main/trunk/interpreter/classes/StringUtil.cpp 2008-08-18 19:24:40 UTC (rev 3002) @@ -1513,3 +1513,40 @@ /* extract the substring */ return new_string(wordStart, wordEnd - wordStart); } + + +/** + * Extract a word from a buffer + * + * @param data The data pointer + * @param length the length of the data buffer. + * @param position the target word position. + * + * @return The string value of the word at the indicated position. + */ +RexxString *StringUtil::word(const char *data, size_t length, RexxInteger *position) +{ + /* convert position to binary */ + size_t wordPos = positionArgument(position, ARG_ONE); + + if (length == 0) /* null string? */ + { + return OREF_NULLSTRING; /* result is null also */ + } + const char *word = data; /* point to the string */ + const char *nextSite = NULL; + /* get the first word */ + size_t wordLength = nextWord(&word, &length, &nextSite); + while (--wordPos > 0 && wordLength != 0) + { /* loop until we reach target */ + word = nextSite; /* copy the start pointer */ + /* get the next word */ + wordLength = nextWord(&word, &length, &nextSite); + } + if (wordLength != 0) /* have a word */ + { + /* extract the string */ + return new_string(word, wordLength); + } + return OREF_NULLSTRING; /* no word, return a null */ +} Modified: main/trunk/interpreter/classes/StringUtil.hpp =================================================================== --- main/trunk/interpreter/classes/StringUtil.hpp 2008-08-18 18:59:58 UTC (rev 3001) +++ main/trunk/interpreter/classes/StringUtil.hpp 2008-08-18 19:24:40 UTC (rev 3002) @@ -82,6 +82,7 @@ static size_t memPos(const char *string, size_t length, char target); static RexxInteger *verify(const char *data, size_t stringLen, RexxString *ref, RexxString *option, RexxInteger *_start, RexxInteger *range); static RexxString *subWord(const char *data, size_t length, RexxInteger *position, RexxInteger *plength); + static RexxString *word(const char *data, size_t length, RexxInteger *position); }; #endif Modified: main/trunk/interpreter/execution/CPPCode.cpp =================================================================== --- main/trunk/interpreter/execution/CPPCode.cpp 2008-08-18 18:59:58 UTC (rev 3001) +++ main/trunk/interpreter/execution/CPPCode.cpp 2008-08-18 19:24:40 UTC (rev 3002) @@ -866,6 +866,7 @@ CPPM(RexxMutableBuffer::caselessMatchChar), CPPM(RexxMutableBuffer::verify), CPPM(RexxMutableBuffer::subWord), +CPPM(RexxMutableBuffer::word), CPPM(RexxSupplier::available), /* Supplier methods */ CPPM(RexxSupplier::next), Modified: main/trunk/interpreter/memory/Setup.cpp =================================================================== --- main/trunk/interpreter/memory/Setup.cpp 2008-08-18 18:59:58 UTC (rev 3001) +++ main/trunk/interpreter/memory/Setup.cpp 2008-08-18 19:24:40 UTC (rev 3002) @@ -954,6 +954,7 @@ defineKernelMethod(CHAR_CASELESSMATCHCHAR ,TheMutableBufferBehaviour, CPPM(RexxMutableBuffer::caselessMatchChar), 2); defineKernelMethod(CHAR_VERIFY ,TheMutableBufferBehaviour, CPPM(RexxMutableBuffer::verify), 4); defineKernelMethod(CHAR_SUBWORD ,TheMutableBufferBehaviour, CPPM(RexxMutableBuffer::subWord), 2); + defineKernelMethod(CHAR_WORD ,TheMutableBufferBehaviour, CPPM(RexxMutableBuffer::word), 1); /* set the scope of the methods to */ /* this classes oref */ This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |
From: <bi...@us...> - 2008-08-18 19:00:03
|
Revision: 3001 http://oorexx.svn.sourceforge.net/oorexx/?rev=3001&view=rev Author: bigrixx Date: 2008-08-18 18:59:58 +0000 (Mon, 18 Aug 2008) Log Message: ----------- [ 2058009 ] add subword to mutablebuffer Modified Paths: -------------- main/trunk/interpreter/classes/MutableBufferClass.cpp main/trunk/interpreter/classes/MutableBufferClass.hpp main/trunk/interpreter/classes/StringClassWord.cpp main/trunk/interpreter/classes/StringUtil.cpp main/trunk/interpreter/classes/StringUtil.hpp main/trunk/interpreter/execution/CPPCode.cpp main/trunk/interpreter/memory/Setup.cpp Modified: main/trunk/interpreter/classes/MutableBufferClass.cpp =================================================================== --- main/trunk/interpreter/classes/MutableBufferClass.cpp 2008-08-18 17:52:46 UTC (rev 3000) +++ main/trunk/interpreter/classes/MutableBufferClass.cpp 2008-08-18 18:59:58 UTC (rev 3001) @@ -1332,3 +1332,17 @@ { return StringUtil::verify(getStringData(), getLength(), ref, option, _start, range); } + + +/** + * Perform a subword extraction from a mutable buffer. + * + * @param position The first word to be extracted. + * @param plength The number of words to extract. + * + * @return The substring containing the extacted words. + */ +RexxString *RexxMutableBuffer::subWord(RexxInteger *position, RexxInteger *plength) +{ + return StringUtil::subWord(getStringData(), getLength(), position, plength); +} Modified: main/trunk/interpreter/classes/MutableBufferClass.hpp =================================================================== --- main/trunk/interpreter/classes/MutableBufferClass.hpp 2008-08-18 17:52:46 UTC (rev 3000) +++ main/trunk/interpreter/classes/MutableBufferClass.hpp 2008-08-18 18:59:58 UTC (rev 3001) @@ -107,6 +107,7 @@ RexxInteger *matchChar(RexxInteger *position_, RexxString *matchSet); RexxInteger *caselessMatchChar(RexxInteger *position_, RexxString *matchSet); RexxInteger *verify(RexxString *, RexxString *, RexxInteger *, RexxInteger *); + RexxString *subWord(RexxInteger *, RexxInteger *); inline const char *getStringData() { return data->getData(); } inline size_t getLength() { return dataLength; } Modified: main/trunk/interpreter/classes/StringClassWord.cpp =================================================================== --- main/trunk/interpreter/classes/StringClassWord.cpp 2008-08-18 17:52:46 UTC (rev 3000) +++ main/trunk/interpreter/classes/StringClassWord.cpp 2008-08-18 18:59:58 UTC (rev 3001) @@ -215,6 +215,7 @@ return Retval; /* return spaced string */ } + /* the SUBWORD function */ /******************************************************************************/ /* Arguments: Starting word postion */ @@ -222,64 +223,12 @@ /* */ /* Returned: string, contains the requested number of words from source */ /******************************************************************************/ -RexxString *RexxString::subWord(RexxInteger *position, - RexxInteger *plength) +RexxString *RexxString::subWord(RexxInteger *position, RexxInteger *plength) { - const char *Word; /* current word pointer */ - const char *WordStart; /* start of substring */ - const char *WordEnd; /* end of the substring */ - const char *NextSite; /* next word */ - size_t WordPos; /* needed word position */ - size_t Count; /* count of words */ - size_t Length; /* remaining length */ - size_t WordLength; /* word size */ - RexxString *Retval; /* return value */ - - /* convert position to binary */ - WordPos = positionArgument(position, ARG_ONE); - /* get num of words to delete, the */ - /* default is "a very large number" */ - Count = optionalLengthArgument(plength, MAXNUM, ARG_TWO); - - Length = this->getLength(); /* get Argument length */ - if (!Length || !Count) /* null string? */ - { - Retval = OREF_NULLSTRING; /* result is null also */ - } - else - { - Word = this->getStringData(); /* point to the string */ - /* get the first word */ - WordLength = StringUtil::nextWord(&Word, &Length, &NextSite); - while (--WordPos && WordLength) - { /* loop until we reach tArget */ - Word = NextSite; /* copy the start pointer */ - /* get the next word */ - WordLength = StringUtil::nextWord(&Word, &Length, &NextSite); - } - if (WordPos) /* run out of words first */ - { - Retval = OREF_NULLSTRING; /* again a null string */ - } - else - { /* count off number of words */ - WordStart = Word; /* save start position */ - WordEnd = Word; /* default end is the same */ - /* loop until we reach tArget */ - while (Count-- && WordLength) - { - WordEnd = Word + WordLength; /* point to the word end */ - Word = NextSite; /* copy the start pointer */ - /* get the next word */ - WordLength = StringUtil::nextWord(&Word, &Length, &NextSite); - } - /* extract the substring */ - Retval = (RexxString *)new_string(WordStart, WordEnd - WordStart); - } - } - return Retval; /* return extracted string */ + return StringUtil::subWord(getStringData(), getLength(), position, plength); } + /* the WORD function */ /******************************************************************************/ /* Arguments: which word we want. */ Modified: main/trunk/interpreter/classes/StringUtil.cpp =================================================================== --- main/trunk/interpreter/classes/StringUtil.cpp 2008-08-18 17:52:46 UTC (rev 3000) +++ main/trunk/interpreter/classes/StringUtil.cpp 2008-08-18 18:59:58 UTC (rev 3001) @@ -1459,3 +1459,57 @@ } } } + + +/** + * Do a subword operation on a buffer of data + * + * @param data The start of the data buffer. + * @param length The length of the buffer + * @param position The starting word position. + * @param plength the count of words to return. + * + * @return The string containing the indicated subwords. + */ +RexxString *StringUtil::subWord(const char *data, size_t length, RexxInteger *position, RexxInteger *plength) +{ + /* convert position to binary */ + size_t wordPos = positionArgument(position, ARG_ONE); + // get num of words to extract. The default is a "very large number + size_t count = optionalLengthArgument(plength, MAXNUM, ARG_TWO); + + // handle cases that will always result in a null string + if (length == 0 || count == 0) + { + return OREF_NULLSTRING; + } + const char *nextSite = NULL; + const char *word = data; + /* get the first word */ + size_t wordLength = nextWord(&word, &length, &nextSite); + while (--wordPos > 0 && wordLength != 0) + { /* loop until we reach tArget */ + word = nextSite; /* copy the start pointer */ + /* get the next word */ + wordLength = nextWord(&word, &length, &nextSite); + } + // we terminated because there was no word found before we reached the + // count position + if (wordPos != 0) + { + return OREF_NULLSTRING; /* again a null string */ + } + + const char *wordStart = data; /* save start position */ + const char *wordEnd = data; /* default end is the same */ + /* loop until we reach tArget */ + while (count-- > 0 && wordLength != 0) + { + wordEnd = word + wordLength; /* point to the word end */ + word = nextSite; /* copy the start pointer */ + /* get the next word */ + wordLength = nextWord(&word, &length, &nextSite); + } + /* extract the substring */ + return new_string(wordStart, wordEnd - wordStart); +} Modified: main/trunk/interpreter/classes/StringUtil.hpp =================================================================== --- main/trunk/interpreter/classes/StringUtil.hpp 2008-08-18 17:52:46 UTC (rev 3000) +++ main/trunk/interpreter/classes/StringUtil.hpp 2008-08-18 18:59:58 UTC (rev 3001) @@ -81,6 +81,7 @@ static size_t caselessCountStr(const char *hayStack, size_t hayStackLength, RexxString *needle); static size_t memPos(const char *string, size_t length, char target); static RexxInteger *verify(const char *data, size_t stringLen, RexxString *ref, RexxString *option, RexxInteger *_start, RexxInteger *range); + static RexxString *subWord(const char *data, size_t length, RexxInteger *position, RexxInteger *plength); }; #endif Modified: main/trunk/interpreter/execution/CPPCode.cpp =================================================================== --- main/trunk/interpreter/execution/CPPCode.cpp 2008-08-18 17:52:46 UTC (rev 3000) +++ main/trunk/interpreter/execution/CPPCode.cpp 2008-08-18 18:59:58 UTC (rev 3001) @@ -865,6 +865,7 @@ CPPM(RexxMutableBuffer::matchChar), CPPM(RexxMutableBuffer::caselessMatchChar), CPPM(RexxMutableBuffer::verify), +CPPM(RexxMutableBuffer::subWord), CPPM(RexxSupplier::available), /* Supplier methods */ CPPM(RexxSupplier::next), Modified: main/trunk/interpreter/memory/Setup.cpp =================================================================== --- main/trunk/interpreter/memory/Setup.cpp 2008-08-18 17:52:46 UTC (rev 3000) +++ main/trunk/interpreter/memory/Setup.cpp 2008-08-18 18:59:58 UTC (rev 3001) @@ -953,6 +953,7 @@ defineKernelMethod(CHAR_MATCHCHAR ,TheMutableBufferBehaviour, CPPM(RexxMutableBuffer::matchChar), 2); defineKernelMethod(CHAR_CASELESSMATCHCHAR ,TheMutableBufferBehaviour, CPPM(RexxMutableBuffer::caselessMatchChar), 2); defineKernelMethod(CHAR_VERIFY ,TheMutableBufferBehaviour, CPPM(RexxMutableBuffer::verify), 4); + defineKernelMethod(CHAR_SUBWORD ,TheMutableBufferBehaviour, CPPM(RexxMutableBuffer::subWord), 2); /* set the scope of the methods to */ /* this classes oref */ This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |
From: <bi...@us...> - 2008-08-18 17:52:43
|
Revision: 3000 http://oorexx.svn.sourceforge.net/oorexx/?rev=3000&view=rev Author: bigrixx Date: 2008-08-18 17:52:46 +0000 (Mon, 18 Aug 2008) Log Message: ----------- [ 2058015 ] Add verifcation length to verify() Modified Paths: -------------- main/trunk/interpreter/classes/MutableBufferClass.cpp main/trunk/interpreter/classes/MutableBufferClass.hpp main/trunk/interpreter/classes/StringClass.hpp main/trunk/interpreter/classes/StringClassMisc.cpp main/trunk/interpreter/classes/StringUtil.cpp main/trunk/interpreter/classes/StringUtil.hpp main/trunk/interpreter/expression/BuiltinFunctions.cpp main/trunk/interpreter/memory/Setup.cpp Modified: main/trunk/interpreter/classes/MutableBufferClass.cpp =================================================================== --- main/trunk/interpreter/classes/MutableBufferClass.cpp 2008-08-18 17:27:50 UTC (rev 2999) +++ main/trunk/interpreter/classes/MutableBufferClass.cpp 2008-08-18 17:52:46 UTC (rev 3000) @@ -1324,10 +1324,11 @@ * @param ref The reference string. * @param option The match/nomatch option. * @param _start The start position for the verify. + * @param range The range to search * * @return The offset of the first match/mismatch within the buffer. */ -RexxInteger *RexxMutableBuffer::verify(RexxString *ref, RexxString *option, RexxInteger *_start) +RexxInteger *RexxMutableBuffer::verify(RexxString *ref, RexxString *option, RexxInteger *_start, RexxInteger *range) { - return StringUtil::verify(getStringData(), getLength(), ref, option, _start); + return StringUtil::verify(getStringData(), getLength(), ref, option, _start, range); } Modified: main/trunk/interpreter/classes/MutableBufferClass.hpp =================================================================== --- main/trunk/interpreter/classes/MutableBufferClass.hpp 2008-08-18 17:27:50 UTC (rev 2999) +++ main/trunk/interpreter/classes/MutableBufferClass.hpp 2008-08-18 17:52:46 UTC (rev 3000) @@ -106,7 +106,7 @@ bool primitiveCaselessMatch(stringsize_t start, RexxString *other, stringsize_t offset, stringsize_t len); RexxInteger *matchChar(RexxInteger *position_, RexxString *matchSet); RexxInteger *caselessMatchChar(RexxInteger *position_, RexxString *matchSet); - RexxInteger *verify(RexxString *, RexxString *, RexxInteger *); + RexxInteger *verify(RexxString *, RexxString *, RexxInteger *, RexxInteger *); inline const char *getStringData() { return data->getData(); } inline size_t getLength() { return dataLength; } Modified: main/trunk/interpreter/classes/StringClass.hpp =================================================================== --- main/trunk/interpreter/classes/StringClass.hpp 2008-08-18 17:27:50 UTC (rev 2999) +++ main/trunk/interpreter/classes/StringClass.hpp 2008-08-18 17:52:46 UTC (rev 3000) @@ -272,7 +272,7 @@ size_t caselessPos(RexxString *, size_t); RexxString *translate(RexxString *, RexxString *, RexxString *, RexxInteger *, RexxInteger *); - RexxInteger *verify(RexxString *, RexxString *, RexxInteger *); + RexxInteger *verify(RexxString *, RexxString *, RexxInteger *, RexxInteger *); RexxInteger *countStrRexx(RexxString *); RexxInteger *caselessCountStrRexx(RexxString *); size_t caselessCountStr(RexxString *); Modified: main/trunk/interpreter/classes/StringClassMisc.cpp =================================================================== --- main/trunk/interpreter/classes/StringClassMisc.cpp 2008-08-18 17:27:50 UTC (rev 2999) +++ main/trunk/interpreter/classes/StringClassMisc.cpp 2008-08-18 17:52:46 UTC (rev 3000) @@ -822,12 +822,13 @@ RexxInteger *RexxString::verify( RexxString *ref, /* compare reference string */ RexxString *option, /* Match/NoMatch option */ - RexxInteger *_start) /* optional starg position */ + RexxInteger *_start, /* optional starg position */ + RexxInteger *range) // length to search /******************************************************************************/ /* Function: String class VERIFY function */ /******************************************************************************/ { - return StringUtil::verify(getStringData(), getLength(), ref, option, _start); + return StringUtil::verify(getStringData(), getLength(), ref, option, _start, range); } Modified: main/trunk/interpreter/classes/StringUtil.cpp =================================================================== --- main/trunk/interpreter/classes/StringUtil.cpp 2008-08-18 17:27:50 UTC (rev 2999) +++ main/trunk/interpreter/classes/StringUtil.cpp 2008-08-18 17:52:46 UTC (rev 3000) @@ -1361,7 +1361,7 @@ * * @return The match/nomatch position, or 0 if nothing was found. */ -RexxInteger *StringUtil::verify(const char *data, size_t stringLen, RexxString *ref, RexxString *option, RexxInteger *_start) +RexxInteger *StringUtil::verify(const char *data, size_t stringLen, RexxString *ref, RexxString *option, RexxInteger *_start, RexxInteger *range) { // get the reference string information ref = stringArgument(ref, ARG_ONE); @@ -1377,15 +1377,18 @@ /* get starting position */ size_t startPos = optionalPositionArgument(_start, 1, ARG_THREE); + size_t stringRange = optionalLengthArgument(range, stringLen - startPos + 1, ARG_FOUR); if (startPos > stringLen) /* beyond end of string? */ { return IntegerZero; /* couldn't find it */ } else { + // adjust the range for seaching + stringRange = Numerics::minVal(stringRange, stringLen - startPos + 1); + /* point at start position */ const char *current = data + startPos - 1; - stringLen -= (startPos - 1); /* reduce the length */ size_t position = 0; /* haven't found it yet */ if (referenceLen == 0) @@ -1405,7 +1408,7 @@ // return the first non-matching character if (opt == VERIFY_NOMATCH) { - while (stringLen-- != 0) + while (stringRange-- != 0) { /* while input left */ char ch = *current++; /* get next char */ /* get reference string */ Modified: main/trunk/interpreter/classes/StringUtil.hpp =================================================================== --- main/trunk/interpreter/classes/StringUtil.hpp 2008-08-18 17:27:50 UTC (rev 2999) +++ main/trunk/interpreter/classes/StringUtil.hpp 2008-08-18 17:52:46 UTC (rev 3000) @@ -80,7 +80,7 @@ static size_t countStr(const char *hayStack, size_t hayStackLength, RexxString *needle); static size_t caselessCountStr(const char *hayStack, size_t hayStackLength, RexxString *needle); static size_t memPos(const char *string, size_t length, char target); - static RexxInteger *verify(const char *data, size_t stringLen, RexxString *ref, RexxString *option, RexxInteger *_start); + static RexxInteger *verify(const char *data, size_t stringLen, RexxString *ref, RexxString *option, RexxInteger *_start, RexxInteger *range); }; #endif Modified: main/trunk/interpreter/expression/BuiltinFunctions.cpp =================================================================== --- main/trunk/interpreter/expression/BuiltinFunctions.cpp 2008-08-18 17:27:50 UTC (rev 2999) +++ main/trunk/interpreter/expression/BuiltinFunctions.cpp 2008-08-18 17:52:46 UTC (rev 3000) @@ -730,11 +730,12 @@ } #define VERIFY_MIN 2 -#define VERIFY_MAX 4 +#define VERIFY_MAX 5 #define VERIFY_string 1 #define VERIFY_reference 2 #define VERIFY_option 3 #define VERIFY_start 4 +#define VERIFY_range 5 BUILTIN(VERIFY) { @@ -747,8 +748,10 @@ RexxString *option = optional_string(VERIFY, option); /* start is optional */ RexxInteger *start = optional_integer(VERIFY, start); + /* start is optional */ + RexxInteger *range = optional_integer(VERIFY, range); /* do the verify function */ - return string->verify(reference, option, start); + return string->verify(reference, option, start, range); } #define DATATYPE_MIN 1 Modified: main/trunk/interpreter/memory/Setup.cpp =================================================================== --- main/trunk/interpreter/memory/Setup.cpp 2008-08-18 17:27:50 UTC (rev 2999) +++ main/trunk/interpreter/memory/Setup.cpp 2008-08-18 17:52:46 UTC (rev 3000) @@ -842,7 +842,7 @@ defineKernelMethod(CHAR_CASELESSLASTPOS ,TheStringBehaviour, CPPM(RexxString::caselessLastPosRexx), 2); defineKernelMethod(CHAR_CASELESSPOS ,TheStringBehaviour, CPPM(RexxString::caselessPosRexx), 2); defineKernelMethod(CHAR_TRANSLATE ,TheStringBehaviour, CPPM(RexxString::translate), 5); - defineKernelMethod(CHAR_VERIFY ,TheStringBehaviour, CPPM(RexxString::verify), 3); + defineKernelMethod(CHAR_VERIFY ,TheStringBehaviour, CPPM(RexxString::verify), 4); defineKernelMethod(CHAR_BITAND ,TheStringBehaviour, CPPM(RexxString::bitAnd), 2); defineKernelMethod(CHAR_BITOR ,TheStringBehaviour, CPPM(RexxString::bitOr), 2); defineKernelMethod(CHAR_BITXOR ,TheStringBehaviour, CPPM(RexxString::bitXor), 2); @@ -952,7 +952,7 @@ defineKernelMethod(CHAR_CASELESSMATCH ,TheMutableBufferBehaviour, CPPM(RexxMutableBuffer::caselessMatch), 4); defineKernelMethod(CHAR_MATCHCHAR ,TheMutableBufferBehaviour, CPPM(RexxMutableBuffer::matchChar), 2); defineKernelMethod(CHAR_CASELESSMATCHCHAR ,TheMutableBufferBehaviour, CPPM(RexxMutableBuffer::caselessMatchChar), 2); - defineKernelMethod(CHAR_VERIFY ,TheMutableBufferBehaviour, CPPM(RexxMutableBuffer::verify), 3); + defineKernelMethod(CHAR_VERIFY ,TheMutableBufferBehaviour, CPPM(RexxMutableBuffer::verify), 4); /* set the scope of the methods to */ /* this classes oref */ This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |
From: <bi...@us...> - 2008-08-18 17:27:46
|
Revision: 2999 http://oorexx.svn.sourceforge.net/oorexx/?rev=2999&view=rev Author: bigrixx Date: 2008-08-18 17:27:50 +0000 (Mon, 18 Aug 2008) Log Message: ----------- [ 2057806 ] add verify to mutablebuffer Modified Paths: -------------- main/trunk/interpreter/classes/MutableBufferClass.cpp main/trunk/interpreter/classes/MutableBufferClass.hpp main/trunk/interpreter/classes/StringClassMisc.cpp main/trunk/interpreter/classes/StringUtil.cpp main/trunk/interpreter/classes/StringUtil.hpp main/trunk/interpreter/execution/CPPCode.cpp main/trunk/interpreter/memory/Setup.cpp Modified: main/trunk/interpreter/classes/MutableBufferClass.cpp =================================================================== --- main/trunk/interpreter/classes/MutableBufferClass.cpp 2008-08-18 16:39:52 UTC (rev 2998) +++ main/trunk/interpreter/classes/MutableBufferClass.cpp 2008-08-18 17:27:50 UTC (rev 2999) @@ -1316,3 +1316,18 @@ } return TheFalseObject; } + + +/** + * Perform a character verify operation on a mutable buffer. + * + * @param ref The reference string. + * @param option The match/nomatch option. + * @param _start The start position for the verify. + * + * @return The offset of the first match/mismatch within the buffer. + */ +RexxInteger *RexxMutableBuffer::verify(RexxString *ref, RexxString *option, RexxInteger *_start) +{ + return StringUtil::verify(getStringData(), getLength(), ref, option, _start); +} Modified: main/trunk/interpreter/classes/MutableBufferClass.hpp =================================================================== --- main/trunk/interpreter/classes/MutableBufferClass.hpp 2008-08-18 16:39:52 UTC (rev 2998) +++ main/trunk/interpreter/classes/MutableBufferClass.hpp 2008-08-18 17:27:50 UTC (rev 2999) @@ -106,6 +106,7 @@ bool primitiveCaselessMatch(stringsize_t start, RexxString *other, stringsize_t offset, stringsize_t len); RexxInteger *matchChar(RexxInteger *position_, RexxString *matchSet); RexxInteger *caselessMatchChar(RexxInteger *position_, RexxString *matchSet); + RexxInteger *verify(RexxString *, RexxString *, RexxInteger *); inline const char *getStringData() { return data->getData(); } inline size_t getLength() { return dataLength; } Modified: main/trunk/interpreter/classes/StringClassMisc.cpp =================================================================== --- main/trunk/interpreter/classes/StringClassMisc.cpp 2008-08-18 16:39:52 UTC (rev 2998) +++ main/trunk/interpreter/classes/StringClassMisc.cpp 2008-08-18 17:27:50 UTC (rev 2999) @@ -818,6 +818,7 @@ return Retval; /* return translated string */ } + RexxInteger *RexxString::verify( RexxString *ref, /* compare reference string */ RexxString *option, /* Match/NoMatch option */ @@ -826,86 +827,7 @@ /* Function: String class VERIFY function */ /******************************************************************************/ { - size_t StartPos; /* start position */ - size_t StringLen; /* length of string */ - size_t Position; /* returned position */ - size_t ReferenceLen; /* length of reference set */ - size_t Temp; /* temporary scan length */ - RexxInteger *Retval; /* return value */ - char Option; /* verify option */ - const char *Reference; /* reference pointer */ - const char *Current; /* current scan position */ - char ch; /* scan character */ - bool Match; /* found a match */ - - ref = stringArgument(ref, ARG_ONE); /* get the reference string */ - ReferenceLen = ref->getLength(); /* get a length also */ - /* get the option, default 'Nomatch' */ - Option = optionalOptionArgument(option, VERIFY_NOMATCH, ARG_TWO); - if (Option != VERIFY_MATCH && /* options are 'Match' and */ - Option != VERIFY_NOMATCH) /* 'NoMatch' */ - { - /* not that either, then its an error*/ - reportException(Error_Incorrect_method_option, "MN", option); - } - - /* get starting position */ - StartPos = optionalPositionArgument(_start, 1, ARG_THREE); - StringLen = this->getLength(); /* get the string length */ - if (StartPos > StringLen) /* beyond end of string? */ - { - Retval = IntegerZero; /* couldn't find it */ - } - else - { - /* point at start position */ - Current = this->getStringData() + StartPos - 1; - StringLen -= (StartPos - 1); /* reduce the length */ - Position = 0; /* haven't found it yet */ - - if (!ReferenceLen) - { /* if verifying a nullstring */ - if (Option == VERIFY_MATCH) /* can't match at all */ - { - Retval = IntegerZero; /* so return zero */ - } - else - { - Retval = new_integer(StartPos);/* non-match at start position */ - } - } - else - { /* need to really search */ - while (StringLen--) - { /* while input left */ - ch = *Current++; /* get next char */ - /* get reference string */ - Reference = ref->getStringData(); - Temp = ReferenceLen; /* copy the reference length */ - Match = false; /* no match yet */ - - while (Temp--) - { /* spin thru reference */ - if (ch == *Reference++) - { /* in reference ? */ - Match = true; /* had a match */ - break; /* quit the loop */ - } - } - /* have needed matching? */ - if ((Match && Option == VERIFY_MATCH) || - (!Match && Option == VERIFY_NOMATCH)) - { - /* calculate the position */ - Position = Current - this->getStringData(); - break; /* done searching */ - } - } - /* format the position */ - Retval = Position ? new_integer(Position) : IntegerZero; - } - } - return Retval; /* return formatted number */ + return StringUtil::verify(getStringData(), getLength(), ref, option, _start); } Modified: main/trunk/interpreter/classes/StringUtil.cpp =================================================================== --- main/trunk/interpreter/classes/StringUtil.cpp 2008-08-18 16:39:52 UTC (rev 2998) +++ main/trunk/interpreter/classes/StringUtil.cpp 2008-08-18 17:27:50 UTC (rev 2999) @@ -1348,3 +1348,111 @@ } return -1; // no match position } + + +/** + * Perform a verify operation on a section of data. + * + * @param data The data pointer + * @param stringLen The length of the string to match + * @param ref The reference search string. + * @param option The match/nomatch option. + * @param _start The starting offset for the match. + * + * @return The match/nomatch position, or 0 if nothing was found. + */ +RexxInteger *StringUtil::verify(const char *data, size_t stringLen, RexxString *ref, RexxString *option, RexxInteger *_start) +{ + // get the reference string information + ref = stringArgument(ref, ARG_ONE); + size_t referenceLen = ref->getLength(); + /* get the option, default 'Nomatch' */ + char opt = optionalOptionArgument(option, VERIFY_NOMATCH, ARG_TWO); + // validate the possibilities + if (opt != VERIFY_MATCH && opt != VERIFY_NOMATCH) + { + /* not that either, then its an error*/ + reportException(Error_Incorrect_method_option, "MN", option); + } + + /* get starting position */ + size_t startPos = optionalPositionArgument(_start, 1, ARG_THREE); + if (startPos > stringLen) /* beyond end of string? */ + { + return IntegerZero; /* couldn't find it */ + } + else + { + /* point at start position */ + const char *current = data + startPos - 1; + stringLen -= (startPos - 1); /* reduce the length */ + size_t position = 0; /* haven't found it yet */ + + if (referenceLen == 0) + { /* if verifying a nullstring */ + if (opt == VERIFY_MATCH) /* can't match at all */ + { + return IntegerZero; /* so return zero */ + } + else + { + return new_integer(startPos);/* non-match at start position */ + } + } + else + { + // we're verifying that all characters are members of the reference set, so + // return the first non-matching character + if (opt == VERIFY_NOMATCH) + { + while (stringLen-- != 0) + { /* while input left */ + char ch = *current++; /* get next char */ + /* get reference string */ + const char *reference = ref->getStringData(); + size_t temp = referenceLen; /* copy the reference length */ + + while (temp != 0) + { /* spin thru reference */ + if (ch == *reference++) + { + // we have a match, so we can leave + break; + } + temp--; + } + // terminate because we tested all characters? + if (temp == 0) + { + // mismatch at this offset + return new_integer(current - data); + } + } + // this is always a non matching situation to get here + return IntegerZero; + } + else + { + while (stringLen-- != 0) + { /* while input left */ + char ch = *current++; /* get next char */ + /* get reference string */ + const char *reference = ref->getStringData(); + size_t temp = referenceLen; /* copy the reference length */ + + while (temp != 0) + { /* spin thru reference */ + if (ch == *reference++) + { + // we found a matching character, return that position + return new_integer(current - data); + } + temp--; + } + } + // this is always a non matching situation to get here + return IntegerZero; + } + } + } +} Modified: main/trunk/interpreter/classes/StringUtil.hpp =================================================================== --- main/trunk/interpreter/classes/StringUtil.hpp 2008-08-18 16:39:52 UTC (rev 2998) +++ main/trunk/interpreter/classes/StringUtil.hpp 2008-08-18 17:27:50 UTC (rev 2999) @@ -80,6 +80,7 @@ static size_t countStr(const char *hayStack, size_t hayStackLength, RexxString *needle); static size_t caselessCountStr(const char *hayStack, size_t hayStackLength, RexxString *needle); static size_t memPos(const char *string, size_t length, char target); + static RexxInteger *verify(const char *data, size_t stringLen, RexxString *ref, RexxString *option, RexxInteger *_start); }; #endif Modified: main/trunk/interpreter/execution/CPPCode.cpp =================================================================== --- main/trunk/interpreter/execution/CPPCode.cpp 2008-08-18 16:39:52 UTC (rev 2998) +++ main/trunk/interpreter/execution/CPPCode.cpp 2008-08-18 17:27:50 UTC (rev 2999) @@ -864,6 +864,7 @@ CPPM(RexxMutableBuffer::caselessMatch), CPPM(RexxMutableBuffer::matchChar), CPPM(RexxMutableBuffer::caselessMatchChar), +CPPM(RexxMutableBuffer::verify), CPPM(RexxSupplier::available), /* Supplier methods */ CPPM(RexxSupplier::next), Modified: main/trunk/interpreter/memory/Setup.cpp =================================================================== --- main/trunk/interpreter/memory/Setup.cpp 2008-08-18 16:39:52 UTC (rev 2998) +++ main/trunk/interpreter/memory/Setup.cpp 2008-08-18 17:27:50 UTC (rev 2999) @@ -952,6 +952,7 @@ defineKernelMethod(CHAR_CASELESSMATCH ,TheMutableBufferBehaviour, CPPM(RexxMutableBuffer::caselessMatch), 4); defineKernelMethod(CHAR_MATCHCHAR ,TheMutableBufferBehaviour, CPPM(RexxMutableBuffer::matchChar), 2); defineKernelMethod(CHAR_CASELESSMATCHCHAR ,TheMutableBufferBehaviour, CPPM(RexxMutableBuffer::caselessMatchChar), 2); + defineKernelMethod(CHAR_VERIFY ,TheMutableBufferBehaviour, CPPM(RexxMutableBuffer::verify), 3); /* set the scope of the methods to */ /* this classes oref */ This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |
From: <bi...@us...> - 2008-08-18 16:39:46
|
Revision: 2998 http://oorexx.svn.sourceforge.net/oorexx/?rev=2998&view=rev Author: bigrixx Date: 2008-08-18 16:39:52 +0000 (Mon, 18 Aug 2008) Log Message: ----------- [ 2057804 ] add matchChar and caselessMatchChar to mutable buffer Modified Paths: -------------- main/trunk/interpreter/classes/MutableBufferClass.cpp main/trunk/interpreter/classes/MutableBufferClass.hpp main/trunk/interpreter/execution/CPPCode.cpp main/trunk/interpreter/memory/Setup.cpp Modified: main/trunk/interpreter/classes/MutableBufferClass.cpp =================================================================== --- main/trunk/interpreter/classes/MutableBufferClass.cpp 2008-08-18 16:21:41 UTC (rev 2997) +++ main/trunk/interpreter/classes/MutableBufferClass.cpp 2008-08-18 16:39:52 UTC (rev 2998) @@ -1242,3 +1242,77 @@ return StringUtil::caselessCompare(getStringData() + _start, other->getStringData() + offset, len) == 0; } + + +/** + * Compare a single character at a give position against + * a set of characters to see if any of the characters is + * a match. + * + * @param position_ The character position + * @param matchSet The set to compare against. + * + * @return true if the character at the give position is any of the characters, + * false if none of them match. + */ +RexxInteger *RexxMutableBuffer::matchChar(RexxInteger *position_, RexxString *matchSet) +{ + stringsize_t position = positionArgument(position_, ARG_ONE); + // the start position must be within the string bounds + if (position > getLength()) + { + reportException(Error_Incorrect_method_position, position); + } + matchSet = stringArgument(matchSet, ARG_TWO); + + stringsize_t _setLength = matchSet->getLength(); + char _matchChar = getChar(position - 1); + + // iterate through the match set looking for a match + for (stringsize_t i = 0; i < _setLength; i++) + { + if (_matchChar == matchSet->getChar(i)) + { + return TheTrueObject; + } + } + return TheFalseObject; +} + + +/** + * Compare a single character at a give position against + * a set of characters to see if any of the characters is + * a match. + * + * @param position_ The character position + * @param matchSet The set to compare against. + * + * @return true if the character at the give position is any of the characters, + * false if none of them match. + */ +RexxInteger *RexxMutableBuffer::caselessMatchChar(RexxInteger *position_, RexxString *matchSet) +{ + stringsize_t position = positionArgument(position_, ARG_ONE); + // the start position must be within the string bounds + if (position > getLength()) + { + reportException(Error_Incorrect_method_position, position); + } + matchSet = stringArgument(matchSet, ARG_TWO); + + stringsize_t _setLength = matchSet->getLength(); + char _matchChar = getChar(position - 1); + _matchChar = toupper(_matchChar); + + // iterate through the match set looking for a match, using a + // caseless compare + for (stringsize_t i = 0; i < _setLength; i++) + { + if (_matchChar == toupper(matchSet->getChar(i))) + { + return TheTrueObject; + } + } + return TheFalseObject; +} Modified: main/trunk/interpreter/classes/MutableBufferClass.hpp =================================================================== --- main/trunk/interpreter/classes/MutableBufferClass.hpp 2008-08-18 16:21:41 UTC (rev 2997) +++ main/trunk/interpreter/classes/MutableBufferClass.hpp 2008-08-18 16:39:52 UTC (rev 2998) @@ -104,6 +104,8 @@ RexxInteger *caselessMatch(RexxInteger *start_, RexxString *other, RexxInteger *offset_, RexxInteger *len_); bool primitiveMatch(stringsize_t start, RexxString *other, stringsize_t offset, stringsize_t len); bool primitiveCaselessMatch(stringsize_t start, RexxString *other, stringsize_t offset, stringsize_t len); + RexxInteger *matchChar(RexxInteger *position_, RexxString *matchSet); + RexxInteger *caselessMatchChar(RexxInteger *position_, RexxString *matchSet); inline const char *getStringData() { return data->getData(); } inline size_t getLength() { return dataLength; } @@ -113,6 +115,7 @@ inline void closeGap(size_t offset, size_t _size, size_t tailSize) { data->closeGap(offset, _size, tailSize); } inline void adjustGap(size_t offset, size_t _size, size_t _newSize) { data->adjustGap(offset, _size, _newSize); } inline void setData(size_t offset, char character, size_t l) { data->setData(offset, character, l); } + inline char getChar(size_t offset) { return getData()[offset]; } static void createInstance(); static RexxClass *classInstance; Modified: main/trunk/interpreter/execution/CPPCode.cpp =================================================================== --- main/trunk/interpreter/execution/CPPCode.cpp 2008-08-18 16:21:41 UTC (rev 2997) +++ main/trunk/interpreter/execution/CPPCode.cpp 2008-08-18 16:39:52 UTC (rev 2998) @@ -862,6 +862,8 @@ CPPM(RexxMutableBuffer::translate), CPPM(RexxMutableBuffer::match), CPPM(RexxMutableBuffer::caselessMatch), +CPPM(RexxMutableBuffer::matchChar), +CPPM(RexxMutableBuffer::caselessMatchChar), CPPM(RexxSupplier::available), /* Supplier methods */ CPPM(RexxSupplier::next), Modified: main/trunk/interpreter/memory/Setup.cpp =================================================================== --- main/trunk/interpreter/memory/Setup.cpp 2008-08-18 16:21:41 UTC (rev 2997) +++ main/trunk/interpreter/memory/Setup.cpp 2008-08-18 16:39:52 UTC (rev 2998) @@ -950,6 +950,8 @@ defineKernelMethod(CHAR_TRANSLATE ,TheMutableBufferBehaviour, CPPM(RexxMutableBuffer::translate), 5); defineKernelMethod(CHAR_MATCH ,TheMutableBufferBehaviour, CPPM(RexxMutableBuffer::match), 4); defineKernelMethod(CHAR_CASELESSMATCH ,TheMutableBufferBehaviour, CPPM(RexxMutableBuffer::caselessMatch), 4); + defineKernelMethod(CHAR_MATCHCHAR ,TheMutableBufferBehaviour, CPPM(RexxMutableBuffer::matchChar), 2); + defineKernelMethod(CHAR_CASELESSMATCHCHAR ,TheMutableBufferBehaviour, CPPM(RexxMutableBuffer::caselessMatchChar), 2); /* set the scope of the methods to */ /* this classes oref */ This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |
From: <mie...@us...> - 2008-08-18 16:21:34
|
Revision: 2997 http://oorexx.svn.sourceforge.net/oorexx/?rev=2997&view=rev Author: miesfeld Date: 2008-08-18 16:21:41 +0000 (Mon, 18 Aug 2008) Log Message: ----------- Remove dead code in rxwinsys. Enhance string2pointer() so that it handles use cases still present in rxwinsys. Modified Paths: -------------- main/trunk/extensions/platform/windows/rxwinsys/rxwinsys.cpp main/trunk/extensions/platform/windows/rxwinsys/winsystm.cls Modified: main/trunk/extensions/platform/windows/rxwinsys/rxwinsys.cpp =================================================================== --- main/trunk/extensions/platform/windows/rxwinsys/rxwinsys.cpp 2008-08-18 16:18:20 UTC (rev 2996) +++ main/trunk/extensions/platform/windows/rxwinsys/rxwinsys.cpp 2008-08-18 16:21:41 UTC (rev 2997) @@ -228,10 +228,19 @@ const char *string, /* string to convert */ void **pointer) /* converted number */ { - if ( ISHEX(string) ) + if ( strlen(string) < 2 ) { + *pointer = NULL; + return FALSE; + } + else if ( string[1] == 'x' && string[0] == '0' ) + { return sscanf(string, "0x%p", pointer) == 1; } + else if ( string[1] == 'X' && string[0] == '0' ) + { + return sscanf(string, "0X%p", pointer) == 1; + } else { return sscanf(string, "%p", pointer) == 1; @@ -1602,23 +1611,6 @@ } -size_t RexxEntry RemoveWinSysFuncs(const char *funcname, size_t argc, CONSTRXSTRING argv[], const char *qname, PRXSTRING retstr) -{ - // this is a NOP now - retstr->strlength = 0; /* set return value */ - return VALID_ROUTINE; -} - - - -size_t RexxEntry InstWinSysFuncs(const char *funcname, size_t argc, CONSTRXSTRING argv[], const char *qname, PRXSTRING retstr) -{ - // this is a NOP now - retstr->strlength = 0; /* set return value */ - return VALID_ROUTINE; -} - - //Functions for reading Event Log //----------------------------------------------------------------------------- @@ -3282,8 +3274,6 @@ // now build the actual entry list RexxRoutineEntry rxwinsys_functions[] = { - REXX_CLASSIC_ROUTINE(InstWinSysFuncs, InstWinSysFuncs), - REXX_CLASSIC_ROUTINE(RemoveWinSysFuncs,RemoveWinSysFuncs), REXX_CLASSIC_ROUTINE(WSRegistryKey, WSRegistryKey), REXX_CLASSIC_ROUTINE(WSRegistryValue, WSRegistryValue), REXX_CLASSIC_ROUTINE(WSRegistryFile, WSRegistryFile), Modified: main/trunk/extensions/platform/windows/rxwinsys/winsystm.cls =================================================================== --- main/trunk/extensions/platform/windows/rxwinsys/winsystm.cls 2008-08-18 16:18:20 UTC (rev 2996) +++ main/trunk/extensions/platform/windows/rxwinsys/winsystm.cls 2008-08-18 16:21:41 UTC (rev 2997) @@ -39,40 +39,22 @@ ::requires 'rxwinsys' LIBRARY -/* This is the base class for all the other Windows... classes. It handles the - * queue counter. +/* This is the base class for all the other Windows... classes. With ooRexx + * 4.0.0 and on, it no longer serves much puprpose. Retained for backwards + * compatibility. */ ::class 'WindowsClassesBase' -::method InitCode attribute +::attribute initCode ::method init - self~InitCode = 0 + self~initCode = 0 + return self~initCode - /* set the global queue to increase the usage counter */ - queuename = RxQueue('CREATE', "WINSYS_GLOBAL_COUNT") - if queuename \= "WINSYS_GLOBAL_COUNT" then call RxQueue 'DELETE', queuename - oldqueue = RxQueue('SET', "WINSYS_GLOBAL_COUNT") - push time() - call RxQueue 'SET', oldqueue +::method deinstall + nop - return self~InitCode - -::method Deinstall - /* set the global queue to check the dialog counter */ - oldqueue = RxQueue('SET', "WINSYS_GLOBAL_COUNT") - num = queued() - if num \= 0 then pull dummy - call RxQueue 'SET', oldqueue - /* if no other program uses functions, delete the queue */ - if num = 1 then do - call RxQueue 'DELETE', "WINSYS_GLOBAL_COUNT" - end - - - - ::class 'WindowsRegistry' subclass WindowsClassesBase public ::method Local_Machine attribute This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |
From: <bi...@us...> - 2008-08-18 16:18:15
|
Revision: 2996 http://oorexx.svn.sourceforge.net/oorexx/?rev=2996&view=rev Author: bigrixx Date: 2008-08-18 16:18:20 +0000 (Mon, 18 Aug 2008) Log Message: ----------- fix arg() bug and add match/caselessmatch Modified Paths: -------------- main/trunk/interpreter/classes/MutableBufferClass.cpp main/trunk/interpreter/classes/MutableBufferClass.hpp main/trunk/interpreter/execution/CPPCode.cpp main/trunk/interpreter/expression/BuiltinFunctions.cpp main/trunk/interpreter/memory/Setup.cpp Modified: main/trunk/interpreter/classes/MutableBufferClass.cpp =================================================================== --- main/trunk/interpreter/classes/MutableBufferClass.cpp 2008-08-18 15:27:25 UTC (rev 2995) +++ main/trunk/interpreter/classes/MutableBufferClass.cpp 2008-08-18 16:18:20 UTC (rev 2996) @@ -1103,3 +1103,142 @@ } return this; } + + +/** + * Test if regions within two strings match. + * + * @param start_ The starting compare position within the target string. This + * must be within the bounds of the string. + * @param other The other compare string. + * @param offset_ The starting offset of the compare string. This must be + * within the string bounds. The default start postion is 1. + * @param len_ The length of the compare substring. The length and the + * offset must specify a valid substring of other. If not + * specified, this defaults to the substring from the + * offset to the end of the string. + * + * @return True if the two regions match, false for any mismatch. + */ +RexxInteger *RexxMutableBuffer::match(RexxInteger *start_, RexxString *other, RexxInteger *offset_, RexxInteger *len_) +{ + stringsize_t _start = positionArgument(start_, ARG_ONE); + // the start position must be within the string bounds + if (_start > getLength()) + { + reportException(Error_Incorrect_method_position, start_); + } + other = stringArgument(other, ARG_TWO); + + stringsize_t offset = optionalPositionArgument(offset_, 1, ARG_THREE); + + if (offset > other->getLength()) + { + reportException(Error_Incorrect_method_position, offset); + } + + stringsize_t len = optionalLengthArgument(len_, other->getLength() - offset + 1, ARG_FOUR); + + if ((offset + len - 1) > other->getLength()) + { + reportException(Error_Incorrect_method_length, len); + } + + return primitiveMatch(_start, other, offset, len) ? TheTrueObject : TheFalseObject; +} + + +/** + * Test if regions within two strings match. + * + * @param start_ The starting compare position within the target string. This + * must be within the bounds of the string. + * @param other The other compare string. + * @param offset_ The starting offset of the compare string. This must be + * within the string bounds. The default start postion is 1. + * @param len_ The length of the compare substring. The length and the + * offset must specify a valid substring of other. If not + * specified, this defaults to the substring from the + * offset to the end of the string. + * + * @return True if the two regions match, false for any mismatch. + */ +RexxInteger *RexxMutableBuffer::caselessMatch(RexxInteger *start_, RexxString *other, RexxInteger *offset_, RexxInteger *len_) +{ + stringsize_t _start = positionArgument(start_, ARG_ONE); + // the start position must be within the string bounds + if (_start > getLength()) + { + reportException(Error_Incorrect_method_position, start_); + } + other = stringArgument(other, ARG_TWO); + + stringsize_t offset = optionalPositionArgument(offset_, 1, ARG_THREE); + + if (offset > other->getLength()) + { + reportException(Error_Incorrect_method_position, offset); + } + + stringsize_t len = optionalLengthArgument(len_, other->getLength() - offset + 1, ARG_FOUR); + + if ((offset + len - 1) > other->getLength()) + { + reportException(Error_Incorrect_method_length, len); + } + + return primitiveCaselessMatch(_start, other, offset, len) ? TheTrueObject : TheFalseObject; +} + + +/** + * Perform a compare of regions of two string objects. Returns + * true if the two regions match, returns false for mismatches. + * + * @param start The starting offset within the target string. + * @param other The source string for the compare. + * @param offset The offset of the substring of the other string to use. + * @param len The length of the substring to compare. + * + * @return True if the regions match, false otherwise. + */ +bool RexxMutableBuffer::primitiveMatch(stringsize_t _start, RexxString *other, stringsize_t offset, stringsize_t len) +{ + _start--; // make the starting point origin zero + offset--; + + // if the match is not possible in the target string, just return false now. + if ((_start + len) > getLength()) + { + return false; + } + + return memcmp(getStringData() + _start, other->getStringData() + offset, len) == 0; +} + + +/** + * Perform a caselesee compare of regions of two string objects. + * Returns true if the two regions match, returns false for + * mismatches. + * + * @param start The starting offset within the target string. + * @param other The source string for the compare. + * @param offset The offset of the substring of the other string to use. + * @param len The length of the substring to compare. + * + * @return True if the regions match, false otherwise. + */ +bool RexxMutableBuffer::primitiveCaselessMatch(stringsize_t _start, RexxString *other, stringsize_t offset, stringsize_t len) +{ + _start--; // make the starting point origin zero + offset--; + + // if the match is not possible in the target string, just return false now. + if ((_start + len) > getLength()) + { + return false; + } + + return StringUtil::caselessCompare(getStringData() + _start, other->getStringData() + offset, len) == 0; +} Modified: main/trunk/interpreter/classes/MutableBufferClass.hpp =================================================================== --- main/trunk/interpreter/classes/MutableBufferClass.hpp 2008-08-18 15:27:25 UTC (rev 2995) +++ main/trunk/interpreter/classes/MutableBufferClass.hpp 2008-08-18 16:18:20 UTC (rev 2996) @@ -100,6 +100,10 @@ RexxMutableBuffer *upper(RexxInteger *_start, RexxInteger *_length); RexxMutableBuffer *lower(RexxInteger *_start, RexxInteger *_length); RexxMutableBuffer *translate(RexxString *tableo, RexxString *tablei, RexxString *pad, RexxInteger *, RexxInteger *); + RexxInteger *match(RexxInteger *start_, RexxString *other, RexxInteger *offset_, RexxInteger *len_); + RexxInteger *caselessMatch(RexxInteger *start_, RexxString *other, RexxInteger *offset_, RexxInteger *len_); + bool primitiveMatch(stringsize_t start, RexxString *other, stringsize_t offset, stringsize_t len); + bool primitiveCaselessMatch(stringsize_t start, RexxString *other, stringsize_t offset, stringsize_t len); inline const char *getStringData() { return data->getData(); } inline size_t getLength() { return dataLength; } Modified: main/trunk/interpreter/execution/CPPCode.cpp =================================================================== --- main/trunk/interpreter/execution/CPPCode.cpp 2008-08-18 15:27:25 UTC (rev 2995) +++ main/trunk/interpreter/execution/CPPCode.cpp 2008-08-18 16:18:20 UTC (rev 2996) @@ -860,6 +860,8 @@ CPPM(RexxMutableBuffer::upper), CPPM(RexxMutableBuffer::lower), CPPM(RexxMutableBuffer::translate), +CPPM(RexxMutableBuffer::match), +CPPM(RexxMutableBuffer::caselessMatch), CPPM(RexxSupplier::available), /* Supplier methods */ CPPM(RexxSupplier::next), Modified: main/trunk/interpreter/expression/BuiltinFunctions.cpp =================================================================== --- main/trunk/interpreter/expression/BuiltinFunctions.cpp 2008-08-18 15:27:25 UTC (rev 2995) +++ main/trunk/interpreter/expression/BuiltinFunctions.cpp 2008-08-18 16:18:20 UTC (rev 2996) @@ -879,6 +879,7 @@ { return OREF_NULLSTRING; /* this too is a null string */ } + return result; // return the argument stuff } } else Modified: main/trunk/interpreter/memory/Setup.cpp =================================================================== --- main/trunk/interpreter/memory/Setup.cpp 2008-08-18 15:27:25 UTC (rev 2995) +++ main/trunk/interpreter/memory/Setup.cpp 2008-08-18 16:18:20 UTC (rev 2996) @@ -948,6 +948,8 @@ defineKernelMethod(CHAR_UPPER ,TheMutableBufferBehaviour, CPPM(RexxMutableBuffer::upper), 2); defineKernelMethod(CHAR_LOWER ,TheMutableBufferBehaviour, CPPM(RexxMutableBuffer::lower), 2); defineKernelMethod(CHAR_TRANSLATE ,TheMutableBufferBehaviour, CPPM(RexxMutableBuffer::translate), 5); + defineKernelMethod(CHAR_MATCH ,TheMutableBufferBehaviour, CPPM(RexxMutableBuffer::match), 4); + defineKernelMethod(CHAR_CASELESSMATCH ,TheMutableBufferBehaviour, CPPM(RexxMutableBuffer::caselessMatch), 4); /* set the scope of the methods to */ /* this classes oref */ This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |
From: <mie...@us...> - 2008-08-18 15:27:16
|
Revision: 2995 http://oorexx.svn.sourceforge.net/oorexx/?rev=2995&view=rev Author: miesfeld Date: 2008-08-18 15:27:25 +0000 (Mon, 18 Aug 2008) Log Message: ----------- Fix size of returned value in rxwinsys. Modified Paths: -------------- main/trunk/extensions/platform/windows/rxwinsys/rxwinsys.cpp Modified: main/trunk/extensions/platform/windows/rxwinsys/rxwinsys.cpp =================================================================== --- main/trunk/extensions/platform/windows/rxwinsys/rxwinsys.cpp 2008-08-18 15:09:02 UTC (rev 2994) +++ main/trunk/extensions/platform/windows/rxwinsys/rxwinsys.cpp 2008-08-18 15:27:25 UTC (rev 2995) @@ -88,6 +88,12 @@ VOID Little2BigEndian(BYTE *pbInt, INT iSize); +size_t dwordPtrToRexx(DWORD_PTR val, PRXSTRING r) +{ + _snprintf(r->strptr, RXAUTOBUFLEN, "%Iu", val); + r->strlength = strlen(r->strptr); + return 0; +} LONG HandleArgError(PRXSTRING r, BOOL ToMuch) { @@ -3072,7 +3078,7 @@ } else { - RETVAL(dwResult); + return dwordPtrToRexx(dwResult, retstr); } } else if ( strcmp(argv[0].strptr, "MAP") == 0 ) This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |
From: <bi...@us...> - 2008-08-18 15:08:54
|
Revision: 2994 http://oorexx.svn.sourceforge.net/oorexx/?rev=2994&view=rev Author: bigrixx Date: 2008-08-18 15:09:02 +0000 (Mon, 18 Aug 2008) Log Message: ----------- a little anal-retentive code cleanup Modified Paths: -------------- main/trunk/interpreter/expression/BuiltinFunctions.cpp Modified: main/trunk/interpreter/expression/BuiltinFunctions.cpp =================================================================== --- main/trunk/interpreter/expression/BuiltinFunctions.cpp 2008-08-18 14:53:50 UTC (rev 2993) +++ main/trunk/interpreter/expression/BuiltinFunctions.cpp 2008-08-18 15:09:02 UTC (rev 2994) @@ -62,11 +62,16 @@ /* checks if pad is a single character string */ -void checkPadArgument(char *pFuncName, RexxObject *position, RexxString *pad) +void checkPadArgument(const char *pFuncName, RexxObject *position, RexxString *pad) { - if (pad == OREF_NULL) return; - if (pad->getLength() != 1) - reportException(Error_Incorrect_call_pad, pFuncName, position, pad); + if (pad == OREF_NULL) + { + return; + } + if (pad->getLength() != 1) + { + reportException(Error_Incorrect_call_pad, pFuncName, position, pad); + } } #define CENTER_MIN 2 @@ -75,19 +80,16 @@ #define CENTER_length 2 #define CENTER_pad 3 -BUILTIN(CENTER) { - RexxString *string; /* target centered string */ - RexxInteger *length; /* target string length */ - RexxString *pad; /* optional pad character */ - - fix_args(CENTER); /* check on required number of args */ - /* force first argument to a string */ - string = required_string(CENTER, string); - /* this is a required length */ - length = required_integer(CENTER, length); - pad = optional_string(CENTER, pad); /* the pad character must be one too */ - checkPadArgument(CHAR_CENTER, IntegerThree, pad); - return string->center(length, pad); /* do the center function */ +BUILTIN(CENTER) +{ + fix_args(CENTER); /* check on required number of args */ + /* force first argument to a string */ + RexxString *string = required_string(CENTER, string); + /* this is a required length */ + RexxInteger *length = required_integer(CENTER, length); + RexxString *pad = optional_string(CENTER, pad); /* the pad character must be one too */ + checkPadArgument(CHAR_CENTER, IntegerThree, pad); + return string->center(length, pad); /* do the center function */ } #define CENTRE_MIN 2 @@ -96,19 +98,16 @@ #define CENTRE_length 2 #define CENTRE_pad 3 -BUILTIN(CENTRE) { - RexxString *string; /* target string */ - RexxInteger *length; /* target string length */ - RexxString *pad; /* optional pad character */ - - fix_args(CENTRE); /* check on required number of args */ - /* force first argument to a string */ - string = required_string(CENTRE, string); - /* this is a required length */ - length = required_integer(CENTRE, length); - pad = optional_string(CENTRE, pad); /* the pad character must be one too */ - checkPadArgument(CHAR_CENTRE, IntegerThree, pad); - return string->center(length, pad); /* do the center function */ +BUILTIN(CENTRE) +{ + fix_args(CENTRE); /* check on required number of args */ + /* force first argument to a string */ + RexxString *string = required_string(CENTRE, string); + /* this is a required length */ + RexxInteger *length = required_integer(CENTRE, length); + RexxString *pad = optional_string(CENTRE, pad); /* the pad character must be one too */ + checkPadArgument(CHAR_CENTRE, IntegerThree, pad); + return string->center(length, pad); /* do the center function */ } #define DELSTR_MIN 2 @@ -117,18 +116,15 @@ #define DELSTR_n 2 #define DELSTR_length 3 -BUILTIN(DELSTR) { - RexxString *string; /* target string */ - RexxInteger *n; /* start position */ - RexxInteger *length; /* target string length */ - - fix_args(DELSTR); /* check on required number of args */ - /* must have the first argument */ - string = required_string(DELSTR, string); - n = required_integer(DELSTR, n); /* need a delete position */ - /* length is optional */ - length = optional_integer(DELSTR, length); - return string->delstr(n, length); /* do the delstr function */ +BUILTIN(DELSTR) +{ + fix_args(DELSTR); /* check on required number of args */ + /* must have the first argument */ + RexxString *string = required_string(DELSTR, string); + RexxInteger *n = required_integer(DELSTR, n); /* need a delete position */ + /* length is optional */ + RexxInteger *length = optional_integer(DELSTR, length); + return string->delstr(n, length); /* do the delstr function */ } #define DELWORD_MIN 2 @@ -137,18 +133,15 @@ #define DELWORD_n 2 #define DELWORD_length 3 -BUILTIN(DELWORD) { - RexxString *string; /* target string */ - RexxInteger *n; /* start position */ - RexxInteger *length; /* target string length */ - - fix_args(DELWORD); /* check on required number of args */ - /* must have the first argument */ - string = required_string(DELWORD, string); - n = required_integer(DELWORD, n); /* need a delete position */ - /* length is optional */ - length = optional_integer(DELWORD, length); - return string->delWord(n, length); /* do the delword function */ +BUILTIN(DELWORD) +{ + fix_args(DELWORD); /* check on required number of args */ + /* must have the first argument */ + RexxString *string = required_string(DELWORD, string); + RexxInteger *n = required_integer(DELWORD, n); /* need a delete position */ + /* length is optional */ + RexxInteger *length = optional_integer(DELWORD, length); + return string->delWord(n, length); /* do the delword function */ } #define INSERT_MIN 2 @@ -159,25 +152,20 @@ #define INSERT_length 4 #define INSERT_pad 5 -BUILTIN(INSERT) { - RexxString *newString; /* new string to insert */ - RexxString *target; /* target string */ - RexxInteger *n; /* start position */ - RexxInteger *length; /* target string length */ - RexxString *pad; /* optional pad character */ - - fix_args(INSERT); /* check on require number of args */ - /* get string for new */ - newString = required_string(INSERT, new); - /* get string for target */ - target = required_string(INSERT, target); - n = optional_integer(INSERT, n); /* insert position is optional */ - /* length is optional */ - length = optional_integer(INSERT, length); - pad = optional_string(INSERT, pad); /* get string for pad */ - /* go perform the insert function */ - checkPadArgument(CHAR_INSERT, IntegerFour, pad); - return target->insert(newString, n, length, pad); +BUILTIN(INSERT) +{ + fix_args(INSERT); /* check on require number of args */ + /* get string for new */ + RexxString *newString = required_string(INSERT, new); + /* get string for target */ + RexxString *target = required_string(INSERT, target); + RexxInteger *n = optional_integer(INSERT, n); /* insert position is optional */ + /* length is optional */ + RexxInteger *length = optional_integer(INSERT, length); + RexxString *pad = optional_string(INSERT, pad); /* get string for pad */ + /* go perform the insert function */ + checkPadArgument(CHAR_INSERT, IntegerFour, pad); + return target->insert(newString, n, length, pad); } #define LEFT_MIN 2 @@ -186,19 +174,16 @@ #define LEFT_length 2 #define LEFT_pad 3 -BUILTIN(LEFT) { - RexxString *string; /* target string */ - RexxInteger *length; /* target string length */ - RexxString *pad; /* optional pad character */ - - fix_args(LEFT); /* check on required number of args */ - /* must have the first argument */ - string = required_string(LEFT, string); - /* length is optional */ - length = optional_integer(LEFT, length); - pad = optional_string(LEFT, pad); /* pad must be a string also */ - checkPadArgument(CHAR_LEFT, IntegerThree, pad); - return string->left(length, pad); /* do the substr function */ +BUILTIN(LEFT) +{ + fix_args(LEFT); /* check on required number of args */ + /* must have the first argument */ + RexxString *string = required_string(LEFT, string); + /* length is optional */ + RexxInteger *length = optional_integer(LEFT, length); + RexxString *pad = optional_string(LEFT, pad); /* pad must be a string also */ + checkPadArgument(CHAR_LEFT, IntegerThree, pad); + return string->left(length, pad); /* do the substr function */ } #define OVERLAY_MIN 2 @@ -209,25 +194,20 @@ #define OVERLAY_length 4 #define OVERLAY_pad 5 -BUILTIN(OVERLAY) { - RexxString *newString; /* new string to overlay */ - RexxString *target; /* target string */ - RexxInteger *n; /* start position */ - RexxInteger *length; /* target string length */ - RexxString *pad; /* optional pad character */ - - fix_args(OVERLAY); /* check on require number of args */ - /* get string for new */ - newString = required_string(OVERLAY, new); - /* get string for target */ - target = required_string(OVERLAY, target); - n = optional_integer(OVERLAY, n); /* overlay position is optional */ - /* length is optional */ - length = optional_integer(OVERLAY, length); - pad = optional_string(OVERLAY, pad); /* get string for pad */ - /* go perform the overlay function */ - checkPadArgument(CHAR_OVERLAY, IntegerFive, pad); - return target->overlay(newString, n, length, pad); +BUILTIN(OVERLAY) +{ + fix_args(OVERLAY); /* check on require number of args */ + /* get string for new */ + RexxString *newString = required_string(OVERLAY, new); + /* get string for target */ + RexxString *target = required_string(OVERLAY, target); + RexxInteger *n = optional_integer(OVERLAY, n); /* overlay position is optional */ + /* length is optional */ + RexxInteger *length = optional_integer(OVERLAY, length); + RexxString *pad = optional_string(OVERLAY, pad); /* get string for pad */ + /* go perform the overlay function */ + checkPadArgument(CHAR_OVERLAY, IntegerFive, pad); + return target->overlay(newString, n, length, pad); } #define POS_MIN 2 @@ -236,19 +216,16 @@ #define POS_haystack 2 #define POS_start 3 -BUILTIN(POS) { - RexxString *needle; /* search needle */ - RexxString *haystack; /* string to search in */ - RexxInteger *start; /* the start position */ - - fix_args(POS); /* check on require number of args */ - /* get string for new */ - needle = required_string(POS, needle); - /* get string for target */ - haystack = required_string(POS, haystack); - start = optional_integer(POS, start);/* start position is optional */ - /* go perform the pos function */ - return haystack->posRexx(needle, start); +BUILTIN(POS) +{ + fix_args(POS); /* check on require number of args */ + /* get string for new */ + RexxString *needle = required_string(POS, needle); + /* get string for target */ + RexxString *haystack = required_string(POS, haystack); + RexxInteger *start = optional_integer(POS, start);/* start position is optional */ + /* go perform the pos function */ + return haystack->posRexx(needle, start); } #define LASTPOS_MIN 2 @@ -257,33 +234,29 @@ #define LASTPOS_haystack 2 #define LASTPOS_start 3 -BUILTIN(LASTPOS) { - RexxString *needle; /* search needle */ - RexxString *haystack; /* string to search in */ - RexxInteger *start; /* the start position */ - - fix_args(LASTPOS); /* check on require number of args */ - /* get string for new */ - needle = required_string(LASTPOS, needle); - /* get string for target */ - haystack = required_string(LASTPOS, haystack); - /* start position is optional */ - start = optional_integer(LASTPOS, start); - /* go perform the lastpos function */ - return haystack->lastPosRexx(needle, start); +BUILTIN(LASTPOS) +{ + fix_args(LASTPOS); /* check on require number of args */ + /* get string for new */ + RexxString *needle = required_string(LASTPOS, needle); + /* get string for target */ + RexxString *haystack = required_string(LASTPOS, haystack); + /* start position is optional */ + RexxInteger *start = optional_integer(LASTPOS, start); + /* go perform the lastpos function */ + return haystack->lastPosRexx(needle, start); } #define REVERSE_MIN 1 #define REVERSE_MAX 1 #define REVERSE_string 1 -BUILTIN(REVERSE) { - RexxString *string; /* target string */ - - fix_args(REVERSE); /* check on require number of args */ - /* get string for string */ - string = required_string(REVERSE, string); - return string->reverse(); /* go perform the reverse function */ +BUILTIN(REVERSE) +{ + fix_args(REVERSE); /* check on require number of args */ + /* get string for string */ + RexxString *string = required_string(REVERSE, string); + return string->reverse(); /* go perform the reverse function */ } #define RIGHT_MIN 2 @@ -292,19 +265,16 @@ #define RIGHT_length 2 #define RIGHT_pad 3 -BUILTIN(RIGHT) { - RexxString *string; /* target string */ - RexxInteger *length; /* target string length */ - RexxString *pad; /* optional pad character */ - - fix_args(RIGHT); /* check on required number of args */ - /* must have the first argument */ - string = required_string(RIGHT, string); - /* length is optional */ - length = optional_integer(RIGHT, length); - pad = optional_string(RIGHT, pad); /* pad must be a string also */ - checkPadArgument(CHAR_RIGHT, IntegerThree, pad); - return string->right(length, pad); /* do the substr function */ +BUILTIN(RIGHT) +{ + fix_args(RIGHT); /* check on required number of args */ + /* must have the first argument */ + RexxString *string = required_string(RIGHT, string); + /* length is optional */ + RexxInteger *length = optional_integer(RIGHT, length); + RexxString *pad = optional_string(RIGHT, pad); /* pad must be a string also */ + checkPadArgument(CHAR_RIGHT, IntegerThree, pad); + return string->right(length, pad); /* do the substr function */ } #define STRIP_MIN 1 @@ -313,20 +283,17 @@ #define STRIP_option 2 #define STRIP_char 3 -BUILTIN(STRIP) { - RexxString *string; /* target string */ - RexxString *option; /* function option */ - RexxString *character; /* character to strip */ - - fix_args(STRIP); /* check on required number of args */ - /* must have the first argument */ - string = required_string(STRIP, string); - /* option must be a string too */ - option = optional_string(STRIP, option); - /* as is char as well */ - character = optional_string(STRIP, char); - /* do the strip function */ - return string->strip(option, character); +BUILTIN(STRIP) +{ + fix_args(STRIP); /* check on required number of args */ + /* must have the first argument */ + RexxString *string = required_string(STRIP, string); + /* option must be a string too */ + RexxString *option = optional_string(STRIP, option); + /* as is char as well */ + RexxString *character = optional_string(STRIP, char); + /* do the strip function */ + return string->strip(option, character); } #define SPACE_MIN 1 @@ -336,18 +303,15 @@ #define SPACE_pad 3 -BUILTIN(SPACE) { - RexxString *string; /* target string */ - RexxInteger *n; /* inter-word spaces */ - RexxString *pad; /* optional pad character */ - - fix_args(SPACE); /* check on required number of args */ - /* must have the first argument */ - string = required_string(SPACE, string); - n = optional_integer(SPACE, n); /* spacing is an optional integer */ - pad = optional_string(SPACE, pad); /* pad must be a string also */ - checkPadArgument(CHAR_SPACE, IntegerThree, pad); - return string->space(n, pad); /* do the space function */ +BUILTIN(SPACE) +{ + fix_args(SPACE); /* check on required number of args */ + /* must have the first argument */ + RexxString *string = required_string(SPACE, string); + RexxInteger *n = optional_integer(SPACE, n); /* spacing is an optional integer */ + RexxString *pad = optional_string(SPACE, pad); /* pad must be a string also */ + checkPadArgument(CHAR_SPACE, IntegerThree, pad); + return string->space(n, pad); /* do the space function */ } #define SUBSTR_MIN 2 @@ -358,22 +322,18 @@ #define SUBSTR_pad 4 -BUILTIN(SUBSTR) { - RexxString *string; /* target string */ - RexxInteger *n; /* start position */ - RexxInteger *length; /* target string length */ - RexxString *pad; /* optional pad character */ - - fix_args(SUBSTR); /* check on required number of args */ - /* must have the first argument */ - string = required_string(SUBSTR, string); - n = required_integer(SUBSTR, n); /* position is required */ - /* length is optional */ - length = optional_integer(SUBSTR, length); - pad = optional_string(SUBSTR, pad); /* pad must be a string also */ - /* do the substr function */ - checkPadArgument(CHAR_SUBSTR, IntegerFour, pad); - return string->substr(n, length, pad); +BUILTIN(SUBSTR) +{ + fix_args(SUBSTR); /* check on required number of args */ + /* must have the first argument */ + RexxString *string = required_string(SUBSTR, string); + RexxInteger *n = required_integer(SUBSTR, n); /* position is required */ + /* length is optional */ + RexxInteger *length = optional_integer(SUBSTR, length); + RexxString *pad = optional_string(SUBSTR, pad); /* pad must be a string also */ + /* do the substr function */ + checkPadArgument(CHAR_SUBSTR, IntegerFour, pad); + return string->substr(n, length, pad); } @@ -384,19 +344,16 @@ #define LOWER_length 3 -BUILTIN(LOWER) { - RexxString *string; /* target string */ - RexxInteger *n; /* start position */ - RexxInteger *length; /* target string length */ - - fix_args(LOWER); /* check on required number of args */ - /* must have the first argument */ - string = required_string(LOWER, string); - n = optional_integer(LOWER, n); /* position is optional */ - /* length is optional */ - length = optional_integer(LOWER, length); - /* do the LOWER function */ - return string->lowerRexx(n, length); +BUILTIN(LOWER) +{ + fix_args(LOWER); /* check on required number of args */ + /* must have the first argument */ + RexxString *string = required_string(LOWER, string); + RexxInteger *n = optional_integer(LOWER, n); /* position is optional */ + /* length is optional */ + RexxInteger *length = optional_integer(LOWER, length); + /* do the LOWER function */ + return string->lowerRexx(n, length); } @@ -407,19 +364,16 @@ #define UPPER_length 3 -BUILTIN(UPPER) { - RexxString *string; /* target string */ - RexxInteger *n; /* start position */ - RexxInteger *length; /* target string length */ - - fix_args(UPPER); /* check on required number of args */ - /* must have the first argument */ - string = required_string(UPPER, string); - n = optional_integer(UPPER, n); /* position is optional */ - /* length is optional */ - length = optional_integer(UPPER, length); - /* do the UPPER function */ - return string->upperRexx(n, length); +BUILTIN(UPPER) +{ + fix_args(UPPER); /* check on required number of args */ + /* must have the first argument */ + RexxString *string = required_string(UPPER, string); + RexxInteger *n = optional_integer(UPPER, n); /* position is optional */ + /* length is optional */ + RexxInteger *length = optional_integer(UPPER, length); + /* do the UPPER function */ + return string->upperRexx(n, length); } @@ -429,18 +383,15 @@ #define SUBWORD_n 2 #define SUBWORD_length 3 -BUILTIN(SUBWORD) { - RexxString *string; /* target string */ - RexxInteger *n; /* required start */ - RexxInteger *length; /* target string length */ - - fix_args(SUBWORD); /* check on required number of args */ - /* must have the first argument */ - string = required_string(SUBWORD, string); - n = required_integer(SUBWORD, n); /* position is required */ - /* length is optional */ - length = optional_integer(SUBWORD, length); - return string->subWord(n, length); /* do the subword function */ +BUILTIN(SUBWORD) +{ + fix_args(SUBWORD); /* check on required number of args */ + /* must have the first argument */ + RexxString *string = required_string(SUBWORD, string); + RexxInteger *n = required_integer(SUBWORD, n); /* position is required */ + /* length is optional */ + RexxInteger *length = optional_integer(SUBWORD, length); + return string->subWord(n, length); /* do the subword function */ } #define WORD_MIN 2 @@ -448,15 +399,13 @@ #define WORD_string 1 #define WORD_n 2 -BUILTIN(WORD) { - RexxString *string; /* target string */ - RexxInteger *n; /* start position */ - - fix_args(WORD); /* check on required number of args */ - /* must have the first argument */ - string = required_string(WORD, string); - n = required_integer(WORD, n); /* position is required */ - return string->word(n); /* do the word function */ +BUILTIN(WORD) +{ + fix_args(WORD); /* check on required number of args */ + /* must have the first argument */ + RexxString *string = required_string(WORD, string); + RexxInteger *n = required_integer(WORD, n); /* position is required */ + return string->word(n); /* do the word function */ } #define WORDINDEX_MIN 2 @@ -464,15 +413,13 @@ #define WORDINDEX_string 1 #define WORDINDEX_n 2 -BUILTIN(WORDINDEX) { - RexxString *string; /* target string */ - RexxInteger *n; /* word number */ - - fix_args(WORDINDEX); /* check on required number of args */ - /* must have the first argument */ - string = required_string(WORDINDEX, string); - n = required_integer(WORDINDEX, n); /* position is required */ - return string->wordIndex(n); /* do the wordindex function */ +BUILTIN(WORDINDEX) +{ + fix_args(WORDINDEX); /* check on required number of args */ + /* must have the first argument */ + RexxString *string = required_string(WORDINDEX, string); + RexxInteger *n = required_integer(WORDINDEX, n); /* position is required */ + return string->wordIndex(n); /* do the wordindex function */ } #define WORDLENGTH_MIN 2 @@ -480,15 +427,13 @@ #define WORDLENGTH_string 1 #define WORDLENGTH_n 2 -BUILTIN(WORDLENGTH) { - RexxString *string; /* target string */ - RexxInteger *n; /* start position */ - - fix_args(WORDLENGTH); /* check on required number of args */ - /* must have the first argument */ - string = required_string(WORDLENGTH, string); - n = required_integer(WORDLENGTH, n); /* position is required */ - return string->wordLength(n); /* do the wordlength function */ +BUILTIN(WORDLENGTH) +{ + fix_args(WORDLENGTH); /* check on required number of args */ + /* must have the first argument */ + RexxString *string = required_string(WORDLENGTH, string); + RexxInteger *n = required_integer(WORDLENGTH, n); /* position is required */ + return string->wordLength(n); /* do the wordlength function */ } #define COPIES_MIN 2 @@ -496,15 +441,13 @@ #define COPIES_string 1 #define COPIES_n 2 -BUILTIN(COPIES) { - RexxString *string; /* target string */ - RexxInteger *n; /* number of copies */ - - fix_args(COPIES); /* check on required number of args */ - /* must have the first argument */ - string = required_string(COPIES, string); - n = required_integer(COPIES, n); /* position is required */ - return string->copies(n); /* do the copies function */ +BUILTIN(COPIES) +{ + fix_args(COPIES); /* check on required number of args */ + /* must have the first argument */ + RexxString *string = required_string(COPIES, string); + RexxInteger *n = required_integer(COPIES, n); /* position is required */ + return string->copies(n); /* do the copies function */ } #define WORDPOS_MIN 2 @@ -513,33 +456,29 @@ #define WORDPOS_string 2 #define WORDPOS_start 3 -BUILTIN(WORDPOS) { - RexxString *string; /* target string */ - RexxString *phrase; /* search phrase */ - RexxInteger *start; /* start position */ - - fix_args(WORDPOS); /* check on required number of args */ - /* must have a phrase string */ - phrase = required_string(WORDPOS, phrase); - /* must have the string argument */ - string = required_string(WORDPOS, string); - /* start position is optional */ - start = optional_integer(WORDPOS, start); - /* do the wordpos function */ - return string->wordPos(phrase, start); +BUILTIN(WORDPOS) +{ + fix_args(WORDPOS); /* check on required number of args */ + /* must have a phrase string */ + RexxString *phrase = required_string(WORDPOS, phrase); + /* must have the string argument */ + RexxString *string = required_string(WORDPOS, string); + /* start position is optional */ + RexxInteger *start = optional_integer(WORDPOS, start); + /* do the wordpos function */ + return string->wordPos(phrase, start); } #define WORDS_MIN 1 #define WORDS_MAX 1 #define WORDS_string 1 -BUILTIN(WORDS) { - RexxString *string; /* target string */ - - fix_args(WORDS); /* check on required number of args */ - /* must have the string argument */ - string = required_string(WORDS, string); - return string->words(); /* do the words function */ +BUILTIN(WORDS) +{ + fix_args(WORDS); /* check on required number of args */ + /* must have the string argument */ + RexxString *string = required_string(WORDS, string); + return string->words(); /* do the words function */ } #define ABBREV_MIN 2 @@ -548,19 +487,16 @@ #define ABBREV_info 2 #define ABBREV_length 3 -BUILTIN(ABBREV) { - RexxString *information; /* information to check */ - RexxString *info; /* target abbreviation */ - RexxInteger *length; /* target string length */ - - fix_args(ABBREV); /* check on required number of args */ - /* information must be a string arg */ - information = required_string(ABBREV, information); - info = required_string(ABBREV, info);/* info must also be a string */ - /* length is optional */ - length = optional_integer(ABBREV, length); - /* check on the abbreviation */ - return information->abbrev(info, length); +BUILTIN(ABBREV) +{ + fix_args(ABBREV); /* check on required number of args */ + /* information must be a string arg */ + RexxString *information = required_string(ABBREV, information); + RexxString *info = required_string(ABBREV, info);/* info must also be a string */ + /* length is optional */ + RexxInteger *length = optional_integer(ABBREV, length); + /* check on the abbreviation */ + return information->abbrev(info, length); } #define BITAND_MIN 1 @@ -569,19 +505,16 @@ #define BITAND_string2 2 #define BITAND_pad 3 -BUILTIN(BITAND) { - RexxString *string1; /* first string */ - RexxString *string2; /* second string */ - RexxString *pad; /* optional pad character */ - - fix_args(BITAND); /* check on required number of args */ - /* must have the first string */ - string1 = required_string(BITAND, string1); - /* second string is optional */ - string2 = optional_string(BITAND, string2); - pad = optional_string(BITAND, pad); /* pad is optional also */ - checkPadArgument(CHAR_BITAND, IntegerThree, pad); - return string1->bitAnd(string2, pad);/* do the bitand function */ +BUILTIN(BITAND) +{ + fix_args(BITAND); /* check on required number of args */ + /* must have the first string */ + RexxString *string1 = required_string(BITAND, string1); + /* second string is optional */ + RexxString *string2 = optional_string(BITAND, string2); + RexxString *pad = optional_string(BITAND, pad); /* pad is optional also */ + checkPadArgument(CHAR_BITAND, IntegerThree, pad); + return string1->bitAnd(string2, pad);/* do the bitand function */ } #define BITOR_MIN 1 @@ -590,19 +523,16 @@ #define BITOR_string2 2 #define BITOR_pad 3 -BUILTIN(BITOR) { - RexxString *string1; /* first string */ - RexxString *string2; /* second string */ - RexxString *pad; /* optional pad character */ - - fix_args(BITOR); /* check on required number of args */ - /* must have the first string */ - string1 = required_string(BITOR, string1); - /* second string is optional */ - string2 = optional_string(BITOR, string2); - pad = optional_string(BITOR, pad); /* pad is optional also */ - checkPadArgument(CHAR_BITOR, IntegerThree, pad); - return string1->bitOr(string2, pad); /* do the bitor function */ +BUILTIN(BITOR) +{ + fix_args(BITOR); /* check on required number of args */ + /* must have the first string */ + RexxString *string1 = required_string(BITOR, string1); + /* second string is optional */ + RexxString *string2 = optional_string(BITOR, string2); + RexxString *pad = optional_string(BITOR, pad); /* pad is optional also */ + checkPadArgument(CHAR_BITOR, IntegerThree, pad); + return string1->bitOr(string2, pad); /* do the bitor function */ } #define BITXOR_MIN 1 @@ -611,71 +541,64 @@ #define BITXOR_string2 2 #define BITXOR_pad 3 -BUILTIN(BITXOR) { - RexxString *string1; /* first string */ - RexxString *string2; /* second string */ - RexxString *pad; /* optional pad character */ - - fix_args(BITXOR); /* check on required number of args */ - /* must have the first string */ - string1 = required_string(BITXOR, string1); - /* second string is optional */ - string2 = optional_string(BITXOR, string2); - pad = optional_string(BITXOR, pad); /* pad is optional also */ - checkPadArgument(CHAR_BITXOR, IntegerThree, pad); - return string1->bitXor(string2, pad);/* do the bitxor function */ +BUILTIN(BITXOR) +{ + fix_args(BITXOR); /* check on required number of args */ + /* must have the first string */ + RexxString *string1 = required_string(BITXOR, string1); + /* second string is optional */ + RexxString *string2 = optional_string(BITXOR, string2); + RexxString *pad = optional_string(BITXOR, pad); /* pad is optional also */ + checkPadArgument(CHAR_BITXOR, IntegerThree, pad); + return string1->bitXor(string2, pad);/* do the bitxor function */ } #define B2X_MIN 1 #define B2X_MAX 1 #define B2X_string 1 -BUILTIN(B2X) { - RexxString *string; /* target string */ - - fix_args(B2X); /* check on required number of args */ - /* must have the first string */ - string = required_string(B2X, string); - return string->b2x(); /* do the b2x function */ +BUILTIN(B2X) +{ + fix_args(B2X); /* check on required number of args */ + /* must have the first string */ + RexxString *string = required_string(B2X, string); + return string->b2x(); /* do the b2x function */ } #define X2B_MIN 1 #define X2B_MAX 1 #define X2B_string 1 -BUILTIN(X2B) { - RexxString *string; /* target string */ - - fix_args(X2B); /* check on required number of args */ - /* must have the first string */ - string = required_string(X2B, string); - return string->x2b(); /* do the x2b function */ +BUILTIN(X2B) +{ + fix_args(X2B); /* check on required number of args */ + /* must have the first string */ + RexxString *string = required_string(X2B, string); + return string->x2b(); /* do the x2b function */ } #define C2X_MIN 1 #define C2X_MAX 1 #define C2X_string 1 -BUILTIN(C2X) { - RexxString *string; /* target string */ - - fix_args(C2X); /* check on required number of args */ - /* must have the first string */ - string = required_string(C2X, string); - return string->c2x(); /* do the c2x function */ +BUILTIN(C2X) +{ + fix_args(C2X); /* check on required number of args */ + /* must have the first string */ + RexxString *string = required_string(C2X, string); + return string->c2x(); /* do the c2x function */ } #define X2C_MIN 1 #define X2C_MAX 1 #define X2C_string 1 -BUILTIN(X2C) { - RexxString *string; /* target string */ - - fix_args(X2C); /* check on required number of args */ - /* must have the first string */ - string = required_string(X2C, string); - return string->x2c(); /* do the x2c function */ +BUILTIN(X2C) +{ + fix_args(X2C); /* check on required number of args */ + /* must have the first string */ + RexxString *string = required_string(X2C, string); + return string->x2c(); /* do the x2c function */ } #define C2D_MIN 1 @@ -683,15 +606,13 @@ #define C2D_string 1 #define C2D_n 2 -BUILTIN(C2D) { - RexxString *string; /* target string */ - RexxInteger *n; /* start position */ - - fix_args(C2D); /* check on required number of args */ - /* must have the first string */ - string = required_string(C2D, string); - n = optional_integer(C2D, n); /* length is optional */ - return string->c2d(n); /* do the c2d function */ +BUILTIN(C2D) +{ + fix_args(C2D); /* check on required number of args */ + /* must have the first string */ + RexxString *string = required_string(C2D, string); + RexxInteger *n = optional_integer(C2D, n); /* length is optional */ + return string->c2d(n); /* do the c2d function */ } #define TRUNC_MIN 1 @@ -699,15 +620,13 @@ #define TRUNC_number 1 #define TRUNC_n 2 -BUILTIN(TRUNC) { - RexxString *number; /* number to truncate */ - RexxInteger *n; /* digits to use */ - - fix_args(TRUNC); /* check on required number of args */ - /* must have the first string */ - number = required_string(TRUNC, number); - n = optional_integer(TRUNC, n); /* length is optional */ - return number->trunc(n); /* do the trunc function */ +BUILTIN(TRUNC) +{ + fix_args(TRUNC); /* check on required number of args */ + /* must have the first string */ + RexxString *number = required_string(TRUNC, number); + RexxInteger *n = optional_integer(TRUNC, n); /* length is optional */ + return number->trunc(n); /* do the trunc function */ } #define X2D_MIN 1 @@ -715,15 +634,13 @@ #define X2D_string 1 #define X2D_n 2 -BUILTIN(X2D) { - RexxString *string; /* target string */ - RexxInteger *n; /* start position */ - - fix_args(X2D); /* check on required number of args */ - /* must have the first string */ - string = required_string(X2D, string); - n = optional_integer(X2D, n); /* length is optional */ - return string->x2d(n); /* do the x2d function */ +BUILTIN(X2D) +{ + fix_args(X2D); /* check on required number of args */ + /* must have the first string */ + RexxString *string = required_string(X2D, string); + RexxInteger *n = optional_integer(X2D, n); /* length is optional */ + return string->x2d(n); /* do the x2d function */ } #define D2X_MIN 1 @@ -731,15 +648,13 @@ #define D2X_string 1 #define D2X_n 2 -BUILTIN(D2X) { - RexxString *string; /* target string */ - RexxInteger *n; /* conversion length */ - - fix_args(D2X); /* check on required number of args */ - /* must have the first string */ - string = required_string(D2X, string); - n = optional_integer(D2X, n); /* length is optional */ - return string->d2x(n); /* do the x2d function */ +BUILTIN(D2X) +{ + fix_args(D2X); /* check on required number of args */ + /* must have the first string */ + RexxString *string = required_string(D2X, string); + RexxInteger *n = optional_integer(D2X, n); /* length is optional */ + return string->d2x(n); /* do the x2d function */ } #define D2C_MIN 1 @@ -747,15 +662,13 @@ #define D2C_string 1 #define D2C_n 2 -BUILTIN(D2C) { - RexxString *string; /* target string */ - RexxInteger *n; /* start position */ - - fix_args(D2C); /* check on required number of args */ - /* must have the first string */ - string = required_string(D2C, string); - n = optional_integer(D2C, n); /* length is optional */ - return string->d2c(n); /* do the x2d function */ +BUILTIN(D2C) +{ + fix_args(D2C); /* check on required number of args */ + /* must have the first string */ + RexxString *string = required_string(D2C, string); + RexxInteger *n = optional_integer(D2C, n); /* length is optional */ + return string->d2c(n); /* do the x2d function */ } #define COMPARE_MIN 2 @@ -764,33 +677,29 @@ #define COMPARE_string2 2 #define COMPARE_pad 3 -BUILTIN(COMPARE) { - RexxString *string1; /* first comparison string */ - RexxString *string2; /* second comparison string */ - RexxString *pad; /* optional pad character */ - - fix_args(COMPARE); /* check on required number of args */ - /* must have the first string */ - string1 = required_string(COMPARE, string1); - /* and the second string also */ - string2 = required_string(COMPARE, string2); - pad = optional_string(COMPARE, pad); /* padding is optional */ - /* do the comparison */ - checkPadArgument(CHAR_COMPARE, IntegerThree, pad); - return string1->compare(string2, pad); +BUILTIN(COMPARE) +{ + fix_args(COMPARE); /* check on required number of args */ + /* must have the first string */ + RexxString *string1 = required_string(COMPARE, string1); + /* and the second string also */ + RexxString *string2 = required_string(COMPARE, string2); + RexxString *pad = optional_string(COMPARE, pad); /* padding is optional */ + /* do the comparison */ + checkPadArgument(CHAR_COMPARE, IntegerThree, pad); + return string1->compare(string2, pad); } #define LENGTH_MIN 1 #define LENGTH_MAX 1 #define LENGTH_string 1 -BUILTIN(LENGTH) { - RexxString *target; /* target of the operation */ - - fix_args(LENGTH); /* check on required number of args */ - /* must have a string */ - target = required_string(LENGTH, string); - return target->lengthRexx(); /* get the length */ +BUILTIN(LENGTH) +{ + fix_args(LENGTH); /* check on required number of args */ + /* must have a string */ + RexxString *target = required_string(LENGTH, string); + return target->lengthRexx(); /* get the length */ } #define TRANSLATE_MIN 1 @@ -802,7 +711,8 @@ #define TRANSLATE_start 5 #define TRANSLATE_range 6 -BUILTIN(TRANSLATE) { +BUILTIN(TRANSLATE) +{ fix_args(TRANSLATE); /* check on required number of args */ /* must have a string */ RexxString *string = required_string(TRANSLATE, string); @@ -826,23 +736,19 @@ #define VERIFY_option 3 #define VERIFY_start 4 -BUILTIN(VERIFY) { - RexxString *string; /* target string */ - RexxString *reference; /* reference characters */ - RexxString *option; /* function option */ - RexxInteger *start; /* start position */ - - fix_args(VERIFY); /* check on required number of args */ - /* must have a string */ - string = required_string(VERIFY, string); - /* reference is also required */ - reference = required_string(VERIFY, reference); - /* the options are optional */ - option = optional_string(VERIFY, option); - /* start is optional */ - start = optional_integer(VERIFY, start); - /* do the verify function */ - return string->verify(reference, option, start); +BUILTIN(VERIFY) +{ + fix_args(VERIFY); /* check on required number of args */ + /* must have a string */ + RexxString *string = required_string(VERIFY, string); + /* reference is also required */ + RexxString *reference = required_string(VERIFY, reference); + /* the options are optional */ + RexxString *option = optional_string(VERIFY, option); + /* start is optional */ + RexxInteger *start = optional_integer(VERIFY, start); + /* do the verify function */ + return string->verify(reference, option, start); } #define DATATYPE_MIN 1 @@ -850,64 +756,68 @@ #define DATATYPE_string 1 #define DATATYPE_type 2 -BUILTIN(DATATYPE) { - RexxString *string; /* target string */ - RexxString *type; /* type to check against */ - - fix_args(DATATYPE); /* check on required number of args */ - /* must have a string */ - string = required_string(DATATYPE, string); - /* type must also be a string */ - type = optional_string(DATATYPE, type); - return string->dataType(type); /* call the datatype method */ +BUILTIN(DATATYPE) +{ + fix_args(DATATYPE); /* check on required number of args */ + /* must have a string */ + RexxString *string = required_string(DATATYPE, string); + /* type must also be a string */ + RexxString *type = optional_string(DATATYPE, type); + return string->dataType(type); /* call the datatype method */ } #define ADDRESS_MIN 0 #define ADDRESS_MAX 0 -BUILTIN(ADDRESS) { - check_args(ADDRESS); /* check on required number of args */ - return context->getAddress(); /* return the current address setting*/ +BUILTIN(ADDRESS) +{ + check_args(ADDRESS); /* check on required number of args */ + return context->getAddress(); /* return the current address setting*/ } #define DIGITS_MIN 0 #define DIGITS_MAX 0 -BUILTIN(DIGITS) { - check_args(DIGITS); /* check on required number of args */ - return new_integer(context->digits()); /* return as an option */ +BUILTIN(DIGITS) +{ + check_args(DIGITS); /* check on required number of args */ + return new_integer(context->digits()); /* return as an option */ } #define FUZZ_MIN 0 #define FUZZ_MAX 0 -BUILTIN(FUZZ) { - check_args(FUZZ); /* check on required number of args */ - return new_integer(context->fuzz()); /* return as an integer object */ +BUILTIN(FUZZ) +{ + check_args(FUZZ); /* check on required number of args */ + return new_integer(context->fuzz()); /* return as an integer object */ } #define FORM_MIN 0 #define FORM_MAX 0 -BUILTIN(FORM) { - check_args(FORM); /* check on required number of args */ - /* return the current form setting */ - return context->form() == Numerics::FORM_SCIENTIFIC ? OREF_SCIENTIFIC : OREF_ENGINEERING; +BUILTIN(FORM) +{ + check_args(FORM); /* check on required number of args */ + /* return the current form setting */ + return context->form() == Numerics::FORM_SCIENTIFIC ? OREF_SCIENTIFIC : OREF_ENGINEERING; } #define USERID_MIN 0 #define USERID_MAX 0 -BUILTIN(USERID) { - check_args(USERID); - return SystemInterpreter::getUserid(); +BUILTIN(USERID) +{ + check_args(USERID); + return SystemInterpreter::getUserid(); } #define ERRORTEXT_MIN 1 #define ERRORTEXT_MAX 1 #define ERRORTEXT_n 1 -BUILTIN(ERRORTEXT) { +BUILTIN(ERRORTEXT) +{ check_args(ERRORTEXT); /* check on required number of args */ /* get the error number */ wholenumber_t error_number = (required_integer(ERRORTEXT, n))->getValue(); @@ -932,103 +842,130 @@ #define ARG_n 1 #define ARG_option 2 -BUILTIN(ARG) { - RexxString *option; /* function option */ - RexxInteger *n; /* arg position count */ - RexxObject *result = OREF_NULL; /* function result */ - RexxObject **arglist; /* activation argument list */ - size_t position; /* position argument */ - size_t size; /* array size */ - - fix_args(ARG); /* expand arguments to full value */ - n = optional_integer(ARG, n); /* get the position info */ - /* get the option string */ - option = optional_string(ARG, option); - /* get the argument array */ - arglist = context->getMethodArgumentList(); - size = context->getMethodArgumentCount(); - /* have an option but no position? */ - if (n == OREF_NULL) { /* no position specified? */ - if (option != OREF_NULL) /* have an option with no position */ - /* raise an error */ - reportException(Error_Incorrect_call_noarg, CHAR_ARG, IntegerOne); - /* return the count as an object */ - result = new_integer(size); - } - else if (option == OREF_NULL) { /* just looking for a specific arg? */ - position = n->getValue(); /* get the integer value */ - /* must be a positive integer */ - positive_integer(position, ARG, IntegerOne); - /* bigger than argument list size? */ - if (size < position) - result = OREF_NULLSTRING; /* just return a null string */ - else { - result = arglist[position - 1]; /* get actual value from arglist */ - if (result == OREF_NULL) /* argument wasn't there? */ - result = OREF_NULLSTRING; /* this too is a null string */ +BUILTIN(ARG) +{ + fix_args(ARG); /* expand arguments to full value */ + RexxInteger *n = optional_integer(ARG, n); /* get the position info */ + /* get the option string */ + RexxString *option = optional_string(ARG, option); + /* get the argument array */ + RexxObject **arglist = context->getMethodArgumentList(); + size_t size = context->getMethodArgumentCount(); + /* have an option but no position? */ + if (n == OREF_NULL) + { /* no position specified? */ + if (option != OREF_NULL) /* have an option with no position */ + { + /* raise an error */ + reportException(Error_Incorrect_call_noarg, CHAR_ARG, IntegerOne); + } + /* return the count as an object */ + return new_integer(size); } - } - else { /* need to process an option */ - position = n->getValue(); /* get the integer value */ - /* must be a positive integer */ - positive_integer(position, ARG, IntegerOne); - - switch (option->getChar(0)) { /* process the option character */ - - case 'A': /* return argument array */ - case 'a': /* return argument array */ - if (position == 1) { /* want it all? */ - /* create an array result for the return */ - result = new (size, arglist) RexxArray; + else if (option == OREF_NULL) + { /* just looking for a specific arg? */ + size_t position = n->getValue(); /* get the integer value */ + /* must be a positive integer */ + positive_integer(position, ARG, IntegerOne); + /* bigger than argument list size? */ + if (size < position) + { + return OREF_NULLSTRING; /* just return a null string */ } - else if (position > size) /* beyond bounds of argument list? */ - /* this is a zero size array */ - result = TheNullArray->copy(); - else { /* need to extract a sub array */ - result = new (size - position + 1, &arglist[position - 1]) RexxArray; + else + { + RexxObject *result = arglist[position - 1]; /* get actual value from arglist */ + if (result == OREF_NULL) /* argument wasn't there? */ + { + return OREF_NULLSTRING; /* this too is a null string */ + } } - break; + } + else + { /* need ... [truncated message content] |
From: <mie...@us...> - 2008-08-18 14:53:42
|
Revision: 2993 http://oorexx.svn.sourceforge.net/oorexx/?rev=2993&view=rev Author: miesfeld Date: 2008-08-18 14:53:50 +0000 (Mon, 18 Aug 2008) Log Message: ----------- Remove private code from orexxole.c Modified Paths: -------------- main/trunk/extensions/platform/windows/ole/orexxole.c Modified: main/trunk/extensions/platform/windows/ole/orexxole.c =================================================================== --- main/trunk/extensions/platform/windows/ole/orexxole.c 2008-08-18 14:32:05 UTC (rev 2992) +++ main/trunk/extensions/platform/windows/ole/orexxole.c 2008-08-18 14:53:50 UTC (rev 2993) @@ -4611,11 +4611,6 @@ } } - if ( counter == 2 ) - { - OleUninitialize(); - } - return ResultObj; } This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |
From: <mie...@us...> - 2008-08-18 14:31:55
|
Revision: 2992 http://oorexx.svn.sourceforge.net/oorexx/?rev=2992&view=rev Author: miesfeld Date: 2008-08-18 14:32:05 +0000 (Mon, 18 Aug 2008) Log Message: ----------- Remove private code from orexxole.c Modified Paths: -------------- main/trunk/extensions/platform/windows/ole/orexxole.c Modified: main/trunk/extensions/platform/windows/ole/orexxole.c =================================================================== --- main/trunk/extensions/platform/windows/ole/orexxole.c 2008-08-18 14:13:16 UTC (rev 2991) +++ main/trunk/extensions/platform/windows/ole/orexxole.c 2008-08-18 14:32:05 UTC (rev 2992) @@ -4540,11 +4540,7 @@ CHAR szBuffer[2048]; int rc = 0; long iLast = iInstanceCount; - static int counter = 0; - printf("counter=%d\n", counter); - counter++; - RexxClassObject OLEObjectClass = context->FindClass("OLEOBJECT"); // if a class argument has been supplied, make sure that it is a class derived @@ -4562,16 +4558,9 @@ if (iInstanceCount == 0) { hResult = OleInitialize(NULL); - printf("Normal OleInitialize thread=%d hResult=0x%08x\n", GetCurrentThreadId(), hResult); } iInstanceCount++; - if ( counter == 2 && iInstanceCount != 1 ) - { - hResult = OleInitialize(NULL); - printf("Extra OleInitialize thread=%d hResult=0x%08x\n", GetCurrentThreadId(), hResult); - } - lpUniBuffer = lpAnsiToUnicode( monikerName, strlen(monikerName) + 1); RexxObjectPtr ResultObj = context->Nil(); This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |
From: <mie...@us...> - 2008-08-18 14:13:07
|
Revision: 2991 http://oorexx.svn.sourceforge.net/oorexx/?rev=2991&view=rev Author: miesfeld Date: 2008-08-18 14:13:16 +0000 (Mon, 18 Aug 2008) Log Message: ----------- Add a reminder note in the orxscrpt stuff to recheck its use of OLEObject functions. (Which are changed slightly due to the new APIs.) Modified Paths: -------------- main/trunk/extensions/platform/windows/orxscrpt/eng2rexx.cpp main/trunk/extensions/platform/windows/orxscrpt/eng2rexx.hpp Modified: main/trunk/extensions/platform/windows/orxscrpt/eng2rexx.cpp =================================================================== --- main/trunk/extensions/platform/windows/orxscrpt/eng2rexx.cpp 2008-08-18 05:07:25 UTC (rev 2990) +++ main/trunk/extensions/platform/windows/orxscrpt/eng2rexx.cpp 2008-08-18 14:13:16 UTC (rev 2991) @@ -255,6 +255,9 @@ if (SUCCEEDED(hResult)) { // success, make REXX object from VARIANT + + // TODO note that Variant2Rexx() can / will return NULLOBJECT if it raises an + // exception. parmblock->rxfnc_retc = Variant2Rexx(context->threadContext, &sResult); state = RXEXIT_HANDLED; FPRINTF2(logfile,"COM invoke ok, got back rexx object %p\n", parmblock->rxfnc_retc); Modified: main/trunk/extensions/platform/windows/orxscrpt/eng2rexx.hpp =================================================================== --- main/trunk/extensions/platform/windows/orxscrpt/eng2rexx.hpp 2008-08-18 05:07:25 UTC (rev 2990) +++ main/trunk/extensions/platform/windows/orxscrpt/eng2rexx.hpp 2008-08-18 14:13:16 UTC (rev 2991) @@ -52,6 +52,8 @@ // these three come from orexxole.c +// TODO note that Variant2Rexx() can / will return NULLOBJECT if it raises an +// exception. RexxObjectPtr Variant2Rexx(RexxThreadContext *, VARIANT *pVariant); VOID Rexx2Variant(RexxThreadContext *, RexxObjectPtr RxObject, VARIANT *pVariant, VARTYPE DestVt, size_t iArgPos); void setCreationCallback(int (__stdcall *f)(CLSID, IUnknown*)); This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |
From: Moritz H. <ant...@gm...> - 2008-08-18 06:16:12
|
[CC to developer's list...] On Mon, 18 Aug 2008 04:09:55 +0000 mie...@us... wrote: > Revision: 2987 > http://oorexx.svn.sourceforge.net/oorexx/?rev=2987&view=rev > Author: miesfeld > Date: 2008-08-18 04:09:55 +0000 (Mon, 18 Aug 2008) > > Log Message: > ----------- > Fix 64-bit compile on Windows. The __INT64_C macro does not seem to be > defined anywhere when using the 64-bit toolset. I ran into the same problem on Solaris... However, I might have an idea where the the macro may be defined, but it's hardly anywhere documented. According to http://docs.sun.com/app/docs/doc/819-5265/bjamo the macro should be defined in <inttypes.h>, but I don't know where it is defined on windows. If this really is a C99 extension then it should be in the same header... I would be cautious if your patch does not produce errors in future because it defines that a ll type has 64 bits, but couldn't this change? Moritz > > Modified Paths: > -------------- > main/trunk/api/platform/windows/rexxplatformdefs.h > > Modified: main/trunk/api/platform/windows/rexxplatformdefs.h > =================================================================== > --- main/trunk/api/platform/windows/rexxplatformdefs.h 2008-08-18 03:37:29 UTC (rev 2986) > +++ main/trunk/api/platform/windows/rexxplatformdefs.h 2008-08-18 04:09:55 UTC (rev 2987) > @@ -38,7 +38,12 @@ > #ifndef REXXPLATFORMDEFS_INCLUDED > #define REXXPLATFORMDEFS_INCLUDED > > -/* Currently there are no defines specific to windows */ > +/* This define is needed for 64-bit compiles on Windows. */ > > +#ifndef __INT64_C > +#define __INT64_C(c) c##LL > +#endif > + > + > #endif /* REXXPLATFORMDEFS_INCLUDED */ > > > > This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. > > ------------------------------------------------------------------------- > This SF.Net email is sponsored by the Moblin Your Move Developer's challenge > Build the coolest Linux based applications with Moblin SDK & win great prizes > Grand prize is a trip for two to an Open Source event anywhere in the world > http://moblin-contest.org/redirect.php?banner_id=100&url=/ > _______________________________________________ > Oorexx-svn mailing list > Oor...@li... > https://lists.sourceforge.net/lists/listinfo/oorexx-svn -- Moritz Hoffmann <ant...@gm...> |