github.com/primecitizens/pcz/std@v0.2.1/core/bytealg/index.native.go

// SPDX-License-Identifier: Apache-2.0
// Copyright 2023 The Prime Citizens
//
// Copyright 2018 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

//go:build pcz && (amd64 || arm64 || s390x || ppc64le || ppc64)

package bytealg

import "github.com/primecitizens/pcz/std/core/cmp"

//go:noescape

// indeSlice returns the index of the first instance of b in a, or -1 if b is not present in a.
// Requires 2 <= len(b) <= indexArgBMaxLen.
func indexSlice(a, b []byte) int

//go:noescape

// index returns the index of the first instance of b in a, or -1 if b is not present in a.
// Requires 2 <= len(b) <= indexArgBMaxLen.
func index(a, b string) int

// IndexSlice returns the index of the first instance of sep in s,
// or -1 if sep is not present in s.
func IndexSlice(s, sep []byte) int {
	n := len(sep)
	switch {
	case n == 0:
		return 0
	case n == 1:
		return IndexSliceByte(s, sep[0])
	case n == len(s):
		if cmp.BytesEqual(sep, s) {
			return 0
		}
		return -1
	case n > len(s):
		return -1
	case n <= indexArgBMaxLen:
		// Use brute force when s and sep both are small
		if len(s) <= MaxBruteForce {
			return indexSlice(s, sep)
		}
		c0 := sep[0]
		c1 := sep[1]
		i := 0
		t := len(s) - n + 1
		fails := 0
		for i < t {
			if s[i] != c0 {
				// IndexSliceByte is faster than indexSlice, so use it as long as
				// we're not getting lots of false positives.
				o := IndexSliceByte(s[i+1:t], c0)
				if o < 0 {
					return -1
				}
				i += o + 1
			}
			if s[i+1] == c1 && cmp.BytesEqual(s[i:i+n], sep) {
				return i
			}
			fails++
			i++
			// Switch to indexSlice when IndexByte produces too many false positives.
			if fails > cutover(i) {
				r := indexSlice(s[i:], sep)
				if r >= 0 {
					return r + i
				}
				return -1
			}
		}
		return -1
	}
	c0 := sep[0]
	c1 := sep[1]
	i := 0
	fails := 0
	t := len(s) - n + 1
	for i < t {
		if s[i] != c0 {
			o := IndexSliceByte(s[i+1:t], c0)
			if o < 0 {
				break
			}
			i += o + 1
		}
		if s[i+1] == c1 && cmp.BytesEqual(s[i:i+n], sep) {
			return i
		}
		i++
		fails++
		if fails >= 4+i>>4 && i < t {
			// Give up on IndexByte, it isn't skipping ahead
			// far enough to be better than Rabin-Karp.
			// Experiments (using IndexPeriodic) suggest
			// the cutover is about 16 byte skips.
			// TODO: if large prefixes of sep are matching
			// we should cutover at even larger average skips,
			// because Equal becomes that much more expensive.
			// This code does not take that effect into account.
			j := IndexRabinKarpBytes(s[i:], sep)
			if j < 0 {
				return -1
			}
			return i + j
		}
	}
	return -1
}

// Index returns the index of the first instance of substr in s,
// or -1 if substr is not present in s.
func Index(s, substr string) int {
	n := len(substr)
	switch {
	case n == 0:
		return 0
	case n == 1:
		return IndexByte(s, substr[0])
	case n == len(s):
		if substr == s {
			return 0
		}
		return -1
	case n > len(s):
		return -1
	case n <= indexArgBMaxLen:
		// Use brute force when s and substr both are small
		if len(s) <= MaxBruteForce {
			return index(s, substr)
		}
		c0 := substr[0]
		c1 := substr[1]
		i := 0
		t := len(s) - n + 1
		fails := 0
		for i < t {
			if s[i] != c0 {
				// IndexByte is faster than index, so use it as long as
				// we're not getting lots of false positives.
				o := IndexByte(s[i+1:t], c0)
				if o < 0 {
					return -1
				}
				i += o + 1
			}
			if s[i+1] == c1 && s[i:i+n] == substr {
				return i
			}
			fails++
			i++
			// Switch to index when IndexByte produces too many false positives.
			if fails > cutover(i) {
				r := index(s[i:], substr)
				if r >= 0 {
					return r + i
				}
				return -1
			}
		}
		return -1
	}
	c0 := substr[0]
	c1 := substr[1]
	i := 0
	t := len(s) - n + 1
	fails := 0
	for i < t {
		if s[i] != c0 {
			o := IndexByte(s[i+1:t], c0)
			if o < 0 {
				return -1
			}
			i += o + 1
		}
		if s[i+1] == c1 && s[i:i+n] == substr {
			return i
		}
		i++
		fails++
		if fails >= 4+i>>4 && i < t {
			// See comment in ../bytes/bytes.go.
			j := IndexRabinKarp(s[i:], substr)
			if j < 0 {
				return -1
			}
			return i + j
		}
	}
	return -1
}