more ProOpen and PostOpen hook points

[nedit-bw.git] / macroSplit.diff

From: Tony Balinski <ajbj@free.fr>
Subject: Extending the split() macro built-in

This patch extends split()'s functionality. It allows limited splitting,
where only a certain number of elements should be retrieved, and also
allows the dropping of the last element found if it is empty.

The limited count avoids the perhaps unnecessary overhead of generating a
large array if only the first few elements are to be used. The dropping of
the empty last element allows simple reconstruction after simple splits,
very useful for lines. For example, given:

        a = get_range(0, $text_length)
        lines = split(a, "\n", "lastnotnull")
        b = ""
        for (i = 0; i < lines[]; i++)
            b = b lines[i] "\n"

assuming that all lines are '\n' terminated, b == a at the end. Otherwise
we have to resort to something like:

        a = get_range(0, $text_length)
        lines = split(a, "\n")
        b = ""
        sep = ""
        for (i = 0; i < lines[]; i++) {
            b = b sep lines[i]
            sep = "\n"
        }

to make a == b at the end. which is trickier (albeit more general).

---

 source/macro.c |  109 +++++++++++++++++++++++++++++++++++++++++++--------------
 1 file changed, 84 insertions(+), 25 deletions(-)

diff --quilt old/source/macro.c new/source/macro.c
--- old/source/macro.c
+++ new/source/macro.c
@@ -3585,14 +3585,39 @@ static int stringCompareMS(WindowInfo *w
 }
 
 /*
-** This function is intended to split strings into an array of substrings
-** Importatnt note: It should always return at least one entry with key 0
-** split("", ",") result[0] = ""
-** split("1,2", ",") result[0] = "1" result[1] = "2"
-** split("1,2,", ",") result[0] = "1" result[1] = "2" result[2] = ""
-** 
-** This behavior is specifically important when used to break up
-** array sub-scripts
+** This function is intended to split strings into an array of substrings.
+**
+**  array = split(string, separator[, searchType][, count][, "lastnotnull"])
+**
+** Mandatory arguments:
+**      string: string to split,
+**      string: separator string or pattern marking where to split
+** Optional arguments:
+**      searchType: separator search type (default is "literal") to use to find
+**          occurrences of separator in string.
+**      count: maximum number of pieces in the returned array (default is
+**          infinite, must be greater than zero); if smaller than or equal to
+**          the number of separators found in string, the last piece will
+**          contain the remainder of the string to split (a count of 1 produces
+**          a single result in the returned array, equal to the original
+**          string).
+**      keyword "lastnotnull": if present, this stops an empty string being
+**          returned in the last entry of the array if the string to split ends
+**          with the separator. This has the effect of returning an empty array
+**          if the string to split is originally empty. Otherwise, the returned
+**          array will always contain at least one element.
+**
+** Important note: It should always return at least one entry with key 0
+** unless "lastnotnull" is present.
+**
+** eg
+**     split("", ",") result[0] = ""
+**     split(",", ",") result[0] = "" result[1] = ""
+**     split("1,2", ",") result[0] = "1" result[1] = "2"
+**     split("1,2,", ",") result[0] = "1" result[1] = "2" result[2] = ""
+**
+**     This behavior is specifically important when used to break up
+**     array sub-scripts (unless "lastnotnull" is present)
 */
 
 static int splitMS(WindowInfo *window, DataValue *argList, int nArgs,
@@ -3605,8 +3630,12 @@ static int splitMS(WindowInfo *window, D
     char indexStr[TYPE_INT_STR_SIZE(int)], *allocIndexStr;
     DataValue element;
     int elementLen;
-    
-    if (nArgs < 2) {
+    int haveSearchType = False;
+    int haveCount = False;
+    int count = 0;
+    int lastnotnull = False;
+
+    if (nArgs < 2 || nArgs > 4) {
         return(wrongNArgsErr(errMsg));
     }
     if (!readStringArg(argList[0], &sourceStr, stringStorage[0], errMsg)) {
@@ -3625,16 +3654,40 @@ static int splitMS(WindowInfo *window, D
         *errMsg = "second argument must be a non-empty string: %s";
         return(False);
     }
-    if (nArgs > 2 && readStringArg(argList[2], &typeSplitStr, stringStorage[2], errMsg)) {
-       if (!StringToSearchType(typeSplitStr, &searchType)) {
+
+    /* get the search type and maximum element count */
+    searchType = SEARCH_LITERAL;
+    for (indexNum = 2; indexNum < nArgs; indexNum++) {
+        if (!readStringArg(argList[indexNum], &typeSplitStr,
+                          stringStorage[indexNum], errMsg)) {
+            *errMsg = "non-scalar arguments not allowed: %s";
+            return(False);
+        }
+        if (strcmp(typeSplitStr, "lastnotnull") == 0) {
+            if (lastnotnull) {
+                *errMsg = "\"lastnotnull\" specified more than once: %s";
+                return(False);
+            }
+            lastnotnull = True;
+        } else if (StringToSearchType(typeSplitStr, &searchType)) {
+            if (haveSearchType) {
+                *errMsg = "split search type supplied more than once: %s";
+                return(False);
+            }
+            haveSearchType = True;
+        } else if (!haveCount &&
+                   readIntArg(argList[indexNum], &count, errMsg)) {
+            haveCount = True;
+            if (count < 1) {
+                *errMsg = "split maximum count must be greater than 0: %s";
+                return(False);
+            }
+        } else {
             *errMsg = "unrecognized argument to %s";
             return(False);
         }
     }
-    else {
-       searchType = SEARCH_LITERAL;
-    }
-    
+
     result->tag = ARRAY_TAG;
     result->val.arrayPtr = ArrayNew();
 
@@ -3651,9 +3704,13 @@ static int splitMS(WindowInfo *window, D
             return(False);
         }
         strcpy(allocIndexStr, indexStr);
-        found = SearchString(sourceStr, splitStr, SEARCH_FORWARD, searchType,
-            False, beginPos, &foundStart, &foundEnd,
-               NULL, NULL, GetWindowDelimiters(window));
+        if (haveCount && --count == 0) {
+            found = 0;
+        } else {
+            found = SearchString(sourceStr, splitStr, SEARCH_FORWARD,
+                        searchType, False, beginPos, &foundStart, &foundEnd,
+                        NULL, NULL, GetWindowDelimiters(window));
+        }
         elementEnd = found ? foundStart : strLength;
         elementLen = elementEnd - lastEnd;
         element.tag = STRING_TAG;
@@ -3688,12 +3745,14 @@ static int splitMS(WindowInfo *window, D
         strcpy(allocIndexStr, indexStr);
         element.tag = STRING_TAG;
         if (lastEnd == strLength) {
-            /* The pattern mathed the end of the string. Add an empty chunk. */
-            element.val.str.rep = PERM_ALLOC_STR("");
-            element.val.str.len = 0;
+            if (!lastnotnull) {
+                /* The pattern matched the end of the string. Add an empty chunk. */
+                element.val.str.rep = PERM_ALLOC_STR("");
+                element.val.str.len = 0;
 
-            if (!ArrayInsert(result, allocIndexStr, &element)) {
-                M_ARRAY_INSERT_FAILURE();
+                if (!ArrayInsert(result, allocIndexStr, &element)) {
+                    M_ARRAY_INSERT_FAILURE();
+                }
             }
         } else {
             /* We skipped the last character to prevent an endless loop. 
@@ -3719,7 +3778,7 @@ static int splitMS(WindowInfo *window, D
             found = SearchString(sourceStr, splitStr, SEARCH_FORWARD, 
                 searchType, False, strLength, &foundStart, &foundEnd, 
                 NULL, NULL, GetWindowDelimiters(window));
-            if (found) {
+            if (found && !lastnotnull) {
                 ++indexNum;
                 sprintf(indexStr, "%d", indexNum);
                 allocIndexStr = AllocString(strlen(indexStr) + 1);