Difference between revisions of "LlParseString2List"

From Second Life Wiki
Jump to: navigation, search
(bug in the duplicate cleanup resulting in improper sorting of collisions for specificaly crafted input.)
Line 33: Line 33:
 
     }
 
     }
 
}</pre>
 
}</pre>
|helpers=<div id="box">
+
|helpers={{LSL Functions/ParseString2List}}
== Function: [[list]] ParseString2List([[string]] {{LSL Param|src}}, [[list]] {{LSL Param|separators}}, [[list]] {{LSL Param|spacers}}, [[integer]] {{LSL Param|ParseStringKeepNulls}}); ==
+
<div style="padding: 0.5em;">
+
Returns a list that is '''{{LSL Param|src}}''' broken into a list, discarding '''{{LSL Param|separators}}''', keeping '''{{LSL Param|spacers}}'''.
+
<div style="padding: 0.0em 0.5em 0.5em 0.5em;" id="box">
+
===if '''{{LSL Param|ParseStringKeepNulls}}''' == [[FALSE]]===
+
Same as '''[[llParseString2List]]''', but not limited to 8 spacers or separators.
+
 
+
Thus substitute a call to the '''[[llParseString2List]]''' function by a call to '''ParseString2List''' whenever you have more than 8 separators or more than 8 spacers.
+
</div><div style="padding: 0.0em 0.5em 0.5em 0.5em;" id="box">
+
===if '''{{LSL Param|ParseStringKeepNulls}}''' != [[FALSE]]===
+
Same as '''[[llParseStringKeepNulls]]''', but not limited to 8 spacers or separators.
+
 
+
Thus substitute a call to the '''[[llParseStringKeepNulls]]''' function by a call to '''ParseString2List''' whenever you have more than 8 separators or more than 8 spacers.
+
</div>
+
<pre>
+
list ParseString2List(string src, list separators, list spacers, integer ParseStringKeepNulls)
+
{//works just like llParseString2List and llParseStringKeepNulls but without
+
//the limits on spacers or separators
+
    list keys;
+
    integer i = spacers != [];
+
    integer offset;
+
    integer test;
+
    list out;
+
    string p;
+
    while(i)
+
        if((p = llList2String(spacers, i = ~-i)))
+
        {
+
            if(~(test = llSubStringIndex(src, p)))
+
            {
+
                if(~(offset = llListFindList(out, (list)p)))
+
                {
+
                    out = llDeleteSubList(out, offset, offset);
+
                    keys = llDeleteSubList(keys, -~(offset << 1), (-~offset) << 1);
+
                }
+
                keys = test + ((~i) + keys);
+
                out = p + out;
+
            }
+
        }
+
    for(i = separators != [];i;)
+
        if((p = llList2String(separators, i = ~-i)))
+
        {
+
            if(~(test = llSubStringIndex(src, p)))
+
            {
+
                if(~(offset = llListFindList(out, (list)p)))
+
                {
+
                    out = llDeleteSubList(out, offset, offset);
+
                    keys = llDeleteSubList(keys, -~(offset << 1), (-~offset) << 1);
+
                }
+
                keys = test + (i + keys);
+
                out = p + out;
+
            }
+
        }
+
    out = [];
+
    offset = 0;
+
    while(keys)
+
    {
+
        list t = llList2List(llListSort(keys, 2, TRUE), 0, 1);
+
        integer r = llListFindList(keys, t);
+
        if((i = llList2Integer(t, 0)) < offset)
+
            keys = llDeleteSubList(keys, r, -~r);
+
        else
+
        {
+
            if(offset != i || ParseStringKeepNulls)
+
                out += llDeleteSubString(src, i - offset, -1);
+
            if(0x80000000 & test = llList2Integer(t, 1))
+
                out += p = llList2String(spacers, ~test);
+
            else
+
                p = llList2String(separators, test);
+
            src = llDeleteSubString(src, 0, ~(offset - (i += llStringLength(p))));
+
            offset = i;
+
            if(~(test = llSubStringIndex(src, p)))
+
                keys = llListReplaceList(keys, (list)(test + offset), r, r);
+
            else
+
                keys = llDeleteSubList(keys, r, -~r);
+
        }
+
    }
+
    if(src != "" || ParseStringKeepNulls)
+
        return out + src;
+
    return out;
+
}//Strife Onizuka
+
</pre></div></div>
+
 
|also_functions=*{{LSLG|llParseStringKeepNulls}}
 
|also_functions=*{{LSLG|llParseStringKeepNulls}}
 
*{{LSLG|llDumpList2String}}
 
*{{LSLG|llDumpList2String}}

Revision as of 01:23, 18 September 2007

Summary

Function: list llParseString2List( string src, list separators, list spacers );

Returns a list that is src broken into a list, discarding separators, keeping spacers, discards any null values generated.

• string src source string
• list separators separators to be discarded
• list spacers spacers to be kept

separators and spacers must be lists of strings, maximum of 8 each.

Caveats

  • To avoid contradiction, every string of the spacers list of strings to keep must not exist in the separators list of strings to discard.
  • Every element in the list will be a string, no matter what you think it should be. Cast the results of llList2String to get what you want.
    • integer my_int = (integer)llList2String(my_list, i);
  • llList2String is used here, as llList2Integer can only handle integers in simple notation, ie. will not handle hexadecimal integers.
All Issues ~ Search JIRA for related Bugs

Examples

default
{
    state_entry()
    {
        // This will say:
        // <A><crazy><fox><.><Saw><the><moon><.><.>
        string my_string = "A crazy fox.  Saw the moon..";
        list my_list = llParseString2List(my_string,[" "],["."]);
        llOwnerSay("<" + llDumpList2String(my_list,"><") + ">");
        
        // This will say:
        //  <A><crazy><fox><.><><><Saw><the><moon><.><><.><>
        my_list = llParseStringKeepNulls(my_string,[" "],["."]);
        llOwnerSay("<" + llDumpList2String(my_list,"><") + ">");
    }
}

Useful Snippets

•  ParseString2List Functions the same as llParseString2List and llParseStringKeepNulls but without limitations.

Deep Notes

Search JIRA for related Issues

Signature

function list llParseString2List( string src, list separators, list spacers );