refactor: move bsearch function to C-code

This commit fixes issue #527 and move the bsearch function to a native
C-code.

The performance is a bit better:

Testing script:
```bash
clear
if [[ `uname` == Darwin ]]; then
    MAX_MEMORY_UNITS=KB
else
    MAX_MEMORY_UNITS=MB
fi

export TIMEFMT='%J   %U  user %S system %P cpu %*E total'$'\n'\
'avg shared (code):         %X KB'$'\n'\
'avg unshared (data/stack): %D KB'$'\n'\
'total (sum):               %K KB'$'\n'\
'max memory:                %M '$MAX_MEMORY_UNITS''$'\n'\
'page faults from disk:     %F'$'\n'\
'other page faults:         %R'

echo "JQ code bsearch"
time /usr/bin/jq -n '[range(30000000)] | bsearch(3000)'

echo "C code bsearch"
time ./jq -n '[range(30000000)] | bsearch(3000)'
````

Results:

```
JQ code bsearch
3000
/usr/bin/jq -n '[range(30000000)] | bsearch(3000)'   8.63s  user 0.77s system 98% cpu 9.542 total
avg shared (code):         0 KB
avg unshared (data/stack): 0 KB
total (sum):               0 KB
max memory:                823 MB
page faults from disk:     1
other page faults:         432828
C code bsearch
3000
./jq -n '[range(30000000)] | bsearch(3000)'   8.44s  user 0.74s system 99% cpu 9.249 total
avg shared (code):         0 KB
avg unshared (data/stack): 0 KB
total (sum):               0 KB
max memory:                824 MB
page faults from disk:     0
other page faults:         432766
```

The results may be better if we can use jvp_array_read, and there is no
need to copy/free the input array in each iteration. I guess that is
like that for API pourposes when the libjq is in use with multiple
threads in place.

Signed-off-by: Eloy Coto <[email protected]>

Author: eloycoto

src/builtin.c

@@ -46,7 +46,6 @@ void *alloca (size_t);
 #include "jv_private.h"
 #include "util.h"
 
-
 #define BINOP(name) \
 static jv f_ ## name(jq_state *jq, jv input, jv a, jv b) { \
   jv_free(input); \
@@ -807,6 +806,62 @@ static jv f_sort_by_impl(jq_state *jq, jv input, jv keys) {
   }
 }
 
+/* Assuming the input array is sorted, bsearch/1 returns */
+/* the index of the target if the target is in the input array; and otherwise */
+/*  (-1 - ix), where ix is the insertion point that would leave the array sorted. */
+/* If the input is not sorted, bsearch will terminate but with irrelevant results. */
+static jv f_bsearch(jq_state *jq, jv input, jv target) {
+    assert(jv_get_kind(input) == JV_KIND_ARRAY);
+    assert(jv_get_kind(target) == JV_KIND_NUMBER);
+    int len = jv_array_length(jv_copy(input));
+    if (len == 0) {
+        return jv_number(-1);
+    } else if (len == 1) {
+        jv val = jv_copy(jv_array_get(jv_copy(input), 0));
+        int result = jv_cmp(target, val);
+        jv_free(val);
+        if (result == 0 ) {
+            return jv_number(0);
+        } else if (result > 0) {
+            return jv_number(-2);
+        } else {
+            return jv_number(-1);
+        }
+    }
+
+    int start = 0;
+    int end = len - 1;
+    jv answer = jv_null();
+    while (start <end) {
+        int mid = (start + end) / 2;
+
+        jv val = jv_array_get(jv_copy(input), mid);
+        int result = jv_cmp(target, val);
+        if (result == 0) {
+            answer = jv_number(mid);
+            break;
+        } else if (start == end ) {
+            answer = jv_number(-1);
+            break;
+        } else if (result < 0 ) {
+            end = mid -1;
+        } else {
+            start = mid +1;
+        }
+    }
+
+    if (jv_equal(answer, jv_null())) {
+        jv val = jv_array_get(jv_copy(input), start);
+        int result = jv_cmp(target, val);
+        if (result < 0) {
+            answer =  jv_number(-1 - start);
+        }else {
+            answer =  jv_number(-2 - start);
+        }
+    }
+    return answer;
+}
+
 static jv f_group_by_impl(jq_state *jq, jv input, jv keys) {
   if (jv_get_kind(input) == JV_KIND_ARRAY &&
       jv_get_kind(keys) == JV_KIND_ARRAY &&
@@ -1754,6 +1809,7 @@ BINOPS
   {f_sort, "sort", 1},
   {f_sort_by_impl, "_sort_by_impl", 2},
   {f_group_by_impl, "_group_by_impl", 2},
+  {f_bsearch, "bsearch", 2},
   {f_min, "min", 1},
   {f_max, "max", 1},
   {f_min_by_impl, "_min_by_impl", 2},

src/builtin.jq

@@ -213,37 +213,6 @@ def tostream:
   getpath($p) |
   reduce path(.[]?) as $q ([$p, .]; [$p+$q]);
 
-# Assuming the input array is sorted, bsearch/1 returns
-# the index of the target if the target is in the input array; and otherwise
-#  (-1 - ix), where ix is the insertion point that would leave the array sorted.
-# If the input is not sorted, bsearch will terminate but with irrelevant results.
-def bsearch($target):
-  if length == 0 then -1
-  elif length == 1 then
-     if $target == .[0] then 0 elif $target < .[0] then -1 else -2 end
-  else . as $in
-    # state variable: [start, end, answer]
-    # where start and end are the upper and lower offsets to use.
-    | [0, length-1, null]
-    | until( .[0] > .[1] ;
-             if .[2] != null then (.[1] = -1)               # i.e. break
-             else
-               ( ( (.[1] + .[0]) / 2 ) | floor ) as $mid
-               | $in[$mid] as $monkey
-               | if $monkey == $target  then (.[2] = $mid)   # success
-                 elif .[0] == .[1]     then (.[1] = -1)     # failure
-                 elif $monkey < $target then (.[0] = ($mid + 1))
-                 else (.[1] = ($mid - 1))
-                 end
-             end )
-    | if .[2] == null then          # compute the insertion point
-         if $in[ .[0] ] < $target then (-2 -.[0])
-         else (-1 -.[0])
-         end
-      else .[2]
-      end
-  end;
-
 # Apply f to composite entities recursively, and to atoms
 def walk(f):
   def w: