com.livecode.list: Add "index of _ before _ in _" accessor.

peter-b · peter-b · commit e1da9a063844 · 2015-03-06T10:18:28.000Z
Add a new operation on lists:

    the index of &lt;tNeedle&gt; before &lt;tPosition&gt; in &lt;tList&gt;

This looks for an element equal to &lt;tNeedle&gt; in the subsequence of
&lt;tList&gt; ending at the 1-based index &lt;tPosition&gt; (exclusive).  It
returns the 1-based index, or 0 if no element of of the subsequence is
equal to &lt;tNeedle&gt;.

There are two variants of the operation:

    the first index of &lt;tNeedle&gt; before &lt;tPosition&gt; in &lt;tList&gt;
    the last index of &lt;tNeedle&gt; before &lt;tPosition&gt; in &lt;tList&gt;

If &lt;tNeedle&gt; is a list, it is considered as an element of &lt;tList&gt; not
as a subsequence of &lt;tList&gt;.
diff --git a/libscript/src/list.mlc b/libscript/src/list.mlc
@@ -76,6 +76,7 @@ public foreign handler MCListExecDeleteLastElementOf(inout Target as List) as un
 
 public foreign handler MCListEvalIndexOfElement(in IsLast as CBool, in Needle as any, in Haystack as List, out Index as LCUIndex) as undefined binds to "<builtin>"
 public foreign handler MCListEvalIndexOfElementAfter(in IsLast as CBool, in Needle as any, in After as LCIndex, in Haystack as List, out Index as LCUIndex) as undefined binds to "<builtin>"
+public foreign handler MCListEvalIndexOfElementBefore(in IsLast as CBool, in Needle as any, in Before as LCIndex, in Haystack as List, out Index as LCUIndex) as undefined binds to "<builtin>"
 
 --
 
@@ -928,4 +929,39 @@ begin
 	MCListEvalIndexOfElementAfter(IsLast, Needle, After, Haystack, output)
 end syntax
 
+/*
+Summary:	Find the first or last occurrence of <Needle> within the head of <Haystack>
+
+Needle:	An expression which evaluates to any value.
+Before:	An expression which evaluates to a valid index in Target.
+Target:	An expression which evaluates to a list.
+
+Returns:	Returns the index in <Haystack>.
+
+Example:
+	variable tVar as List
+	variable tOffset as Number
+	put ["a", "b", "c", "d", "b"]
+	put the index of "b" before 2 in tVar into tOffset
+	--tOffset contains 0
+
+	put the first index of "b" before 5 in tVar into tOffset
+	--tOffset contains 2
+
+Description:
+Use `the index of… before` to find where particular elements occur
+within a list.  <Haystack> is scanned for an element that is equal to
+<Needle>, stopping before the position <Before>, and the position of
+the element found is returned.  If no element of <Haystack> is equal
+to <Needle>, the return value is 0.  If neither "first" nor "last" is
+specified, the last matching element is found.
+
+Tags: Lists
+*/
+syntax ListIndexBefore is prefix operator with precedence 1
+	"the" ( "first" <IsLast=false> | "last" <IsLast=true> | <IsLast=true> ) "index" "of" <Needle: Expression> "before" <Before: Expression> "in" <Haystack: Expression>
+begin
+	MCListEvalIndexOfElementBefore(IsLast, Needle, Before, Haystack, output)
+end syntax
+
 end module
diff --git a/libscript/src/module-list.cpp b/libscript/src/module-list.cpp
@@ -503,6 +503,30 @@ MCListEvalIndexOfElementAfter (bool p_is_last,
 	                                 r_output);
 }
 
+extern "C" MC_DLLEXPORT void
+MCListEvalIndexOfElementBefore (bool p_is_last,
+                               MCValueRef p_needle,
+                               index_t p_before,
+                               MCProperListRef p_haystack,
+                               uindex_t & r_output)
+{
+	uindex_t t_start, t_count;
+	if (p_before == 0)
+	{
+		t_start = UINDEX_MAX;
+	} else if (!MCChunkGetExtentsOfElementChunkByExpressionInRange (p_haystack,
+	                nil, p_before, true, false, true, t_start, t_count))
+	{
+		MCErrorCreateAndThrow (kMCGenericErrorTypeInfo, "reason",
+		                       MCSTR("chunk index out of range"), nil);
+		return;
+	}
+
+	MCListEvalIndexOfElementInRange (p_is_last, p_needle, p_haystack,
+	                                 MCRangeMake(0, t_start),
+	                                 r_output);
+}
+
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 
 #ifdef _TEST
diff --git a/tests/lcb/stdlib/list.lcb b/tests/lcb/stdlib/list.lcb
@@ -376,6 +376,8 @@ public handler TestRepeatElement()
 	test "repeat element (count)" when tCount is 4
 end handler
 
+----------------------------------------------------------------
+-- Finding indices
 ----------------------------------------------------------------
 
 public handler TestIndex()
@@ -392,6 +394,8 @@ public handler TestIndex()
 	test "index (empty)" when the index of 1 in [] is 0
 end handler
 
+----------------------------------------------------------------
+
 handler TestIndexAfter_InvalidPositive()
 	return the index of true after 2 in [true]
 end handler
@@ -465,4 +469,80 @@ public handler TestIndexAfterZero()
 	test "last index after (+ve, 0)" when the last index of true after 0 in t is tNoAfter
 end handler
 
+----------------------------------------------------------------
+
+handler TestIndexBefore_InvalidPositive()
+	return the index of true before 3 in [true]
+end handler
+handler TestIndexBefore_InvalidNegative()
+	return the index of true before -2 in [true]
+end handler
+handler TestFirstIndexBefore_InvalidPositive()
+	return the first index of true before 3 in [true]
+end handler
+handler TestFirstIndexBefore_InvalidNegative()
+	return the first index of true before -2 in [true]
+end handler
+handler TestLastIndexBefore_InvalidPositive()
+	return the last index of true before 3 in [true]
+end handler
+handler TestLastIndexBefore_InvalidNegative()
+	return the last index of true before -2 in [true]
+end handler
+public handler TestIndexBefore()
+	variable t
+	put [false, true, true, false, true] into t
+
+	test "index before (+ve)" when the index of true before 4 in t is 3
+	test "index before (-ve)" when the index of true before -2 in t is 3
+	test "index before (+ve, limit)" when the index of true before 6 in t is 5
+	test "index before (+ve, missing)" when the index of true before 2 in t is 0
+	test "index before (-ve, missing)" when the index of true before -4 in t is 0
+
+	MCUnitTestHandlerThrows(TestIndexBefore_InvalidPositive, "index before (+ve, invalid)")
+	MCUnitTestHandlerThrows(TestIndexBefore_InvalidNegative, "index before (-ve, invalid)")
+end handler
+public handler TestFirstIndexBefore()
+	variable t
+	put [false, true, true, false, true] into t
+
+	test "first index before (+ve)" when the first index of true before 4 in t is 2
+	test "first index before (-ve)" when the first index of true before -2 in t is 2
+	test "first index before (+ve, limit)" when the first index of true before 6 in t is 2
+	test "first index before (+ve, missing)" when the first index of true before 2 in t is 0
+	test "first index before (-ve, missing)" when the first index of true before -4 in t is 0
+
+	MCUnitTestHandlerThrows(TestFirstIndexBefore_InvalidPositive, "first index before (+ve, invalid)")
+	MCUnitTestHandlerThrows(TestFirstIndexBefore_InvalidNegative, "first index before (-ve, invalid)")
+end handler
+public handler TestLastIndexBefore()
+	variable t
+	put [false, true, true, false, true] into t
+
+	test "last index before (+ve)" when the last index of true before 4 in t is 3
+	test "last index before (-ve)" when the last index of true before -2 in t is 3
+	test "last index before (+ve, limit)" when the last index of true before 6 in t is 5
+	test "last index before (+ve, missing)" when the last index of true before 2 in t is 0
+	test "last index before (-ve, missing)" when the last index of true before -4 in t is 0
+
+	MCUnitTestHandlerThrows(TestLastIndexBefore_InvalidPositive, "last index before (+ve, invalid)")
+	MCUnitTestHandlerThrows(TestLastIndexBefore_InvalidNegative, "last index before (-ve, invalid)")
+end handler
+public handler TestIndexBeforeZero()
+	-- "index of _ before 0 in _" should be equivalent to
+	-- "last index of _ in _"
+	variable t
+	put [false, true, true, false, true] into t
+	variable tNoBefore
+
+	put the last index of true in t into tNoBefore
+	test "index before (+ve, 0)" when the index of true before 0 in t is tNoBefore
+
+	put the first index of true in t into tNoBefore
+	test "first index before (+ve, 0)" when the first index of true before 0 in t is tNoBefore
+
+	put the last index of true in t into tNoBefore
+	test "last index before (+ve, 0)" when the last index of true before 0 in t is tNoBefore
+end handler
+
 end module
