libgo/go/bytes/bytes_arm64.go

   1 // Copyright 2017 The Go Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style
   3 // license that can be found in the LICENSE file.
   4
   5 // +build ignore
   6
   7 package bytes
   8
   9 func countByte(s []byte, c byte) int // bytes_arm64.s
  10
  11 // Index returns the index of the first instance of sep in s, or -1 if sep is not present in s.
  12 func Index(s, sep []byte) int {
  13         n := len(sep)
  14         switch {
  15         case n == 0:
  16                 return 0
  17         case n == 1:
  18                 return IndexByte(s, sep[0])
  19         case n == len(s):
  20                 if Equal(sep, s) {
  21                         return 0
  22                 }
  23                 return -1
  24         case n > len(s):
  25                 return -1
  26         }
  27         c := sep[0]
  28         i := 0
  29         fails := 0
  30         t := s[:len(s)-n+1]
  31         for i < len(t) {
  32                 if t[i] != c {
  33                         o := IndexByte(t[i:], c)
  34                         if o < 0 {
  35                                 break
  36                         }
  37                         i += o
  38                 }
  39                 if Equal(s[i:i+n], sep) {
  40                         return i
  41                 }
  42                 i++
  43                 fails++
  44                 if fails >= 4+i>>4 && i < len(t) {
  45                         // Give up on IndexByte, it isn't skipping ahead
  46                         // far enough to be better than Rabin-Karp.
  47                         // Experiments (using IndexPeriodic) suggest
  48                         // the cutover is about 16 byte skips.
  49                         // TODO: if large prefixes of sep are matching
  50                         // we should cutover at even larger average skips,
  51                         // because Equal becomes that much more expensive.
  52                         // This code does not take that effect into account.
  53                         j := indexRabinKarp(s[i:], sep)
  54                         if j < 0 {
  55                                 return -1
  56                         }
  57                         return i + j
  58                 }
  59         }
  60         return -1
  61 }
  62
  63 // Count counts the number of non-overlapping instances of sep in s.
  64 // If sep is an empty slice, Count returns 1 + the number of UTF-8-encoded code points in s.
  65 func Count(s, sep []byte) int {
  66         if len(sep) == 1 {
  67                 return countByte(s, sep[0])
  68         }
  69         return countGeneric(s, sep)
  70 }