Menu
▾
▴
[Oorexx-svn] SF.net SVN: oorexx:[2994] main/trunk/interpreter/expression/ BuiltinFunctions.cpp
|
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] |