libgo/go/internal/bytealg/bytealg.c

   1 /* bytealg.c -- gccgo implementations of bytealg functions
   2
   3    Copyright 2018 The Go Authors. All rights reserved.
   4    Use of this source code is governed by a BSD-style
   5    license that can be found in the LICENSE file.  */
   6
   7 #include <stddef.h>
   8 #include <string.h>
   9
  10 #include "runtime.h"
  11 #include "array.h"
  12
  13 #ifndef HAVE_MEMMEM
  14
  15 #define memmem goMemmem
  16
  17 static const void *goMemmem(const void *in, size_t inl, const void *s, size_t sl) {
  18         const char *p;
  19         char first;
  20         const char *stop;
  21
  22         if (sl == 0) {
  23                 return in;
  24         }
  25         if (inl < sl) {
  26                 return nil;
  27         }
  28         first = *(const char *)(s);
  29         stop = (const char *)(in) + (inl - sl);
  30         for (p = (const char *)(in); p <= stop; p++) {
  31                 if (*p == first && __builtin_memcmp(p + 1, (const char *)(s) + 1, sl - 1) == 0) {
  32                         return (const void *)(p);
  33                 }
  34         }
  35         return nil;
  36 }
  37
  38 #endif
  39
  40 intgo Compare(struct __go_open_array, struct __go_open_array)
  41   __asm__(GOSYM_PREFIX "internal_1bytealg.Compare")
  42   __attribute__((no_split_stack));
  43
  44 intgo Compare(struct __go_open_array a, struct __go_open_array b)
  45 {
  46         intgo l;
  47
  48         l = a.__count;
  49         if (b.__count < l) {
  50                 l = b.__count;
  51         }
  52         if (l > 0 && a.__values != b.__values) {
  53                 int i;
  54
  55                 i = __builtin_memcmp(a.__values, b.__values, (size_t)(l));
  56                 if (i < 0) {
  57                         return -1;
  58                 } else if (i > 0) {
  59                         return 1;
  60                 }
  61         }
  62         if (a.__count < b.__count) {
  63                 return -1;
  64         }
  65         if (a.__count > b.__count) {
  66                 return +1;
  67         }
  68         return 0;
  69 }
  70
  71 intgo IndexByte(struct __go_open_array, byte)
  72   __asm__(GOSYM_PREFIX "internal_1bytealg.IndexByte")
  73   __attribute__((no_split_stack));
  74
  75 intgo IndexByte(struct __go_open_array b, byte c)
  76 {
  77         const byte *p;
  78
  79         p = __builtin_memchr(b.__values, c, (size_t)(b.__count));
  80         if (p == nil) {
  81                 return -1;
  82         }
  83         return p - (byte *)(b.__values);
  84 }
  85
  86
  87 intgo IndexByteString(String, byte)
  88   __asm__(GOSYM_PREFIX "internal_1bytealg.IndexByteString")
  89   __attribute__((no_split_stack));
  90
  91 intgo IndexByteString(String s, byte c)
  92 {
  93         const byte *p;
  94
  95         p = __builtin_memchr(s.str, c, (size_t)(s.len));
  96         if (p == nil) {
  97                 return -1;
  98         }
  99         return p - s.str;
 100 }
 101
 102 intgo Index(struct __go_open_array, struct __go_open_array)
 103   __asm__(GOSYM_PREFIX "internal_1bytealg.Index")
 104   __attribute__((no_split_stack));
 105
 106 intgo Index(struct __go_open_array a, struct __go_open_array b)
 107 {
 108         const byte* p;
 109
 110         p = memmem(a.__values, a.__count, b.__values, b.__count);
 111         if (p == nil) {
 112                 return -1;
 113         }
 114         return p - (const byte*)(a.__values);
 115 }
 116
 117 intgo IndexString(String, String)
 118   __asm__(GOSYM_PREFIX "internal_1bytealg.IndexString")
 119   __attribute__((no_split_stack));
 120
 121 intgo IndexString(String a, String b)
 122 {
 123         const byte* p;
 124
 125         p = memmem(a.str, a.len, b.str, b.len);
 126         if (p == nil) {
 127                 return -1;
 128         }
 129         return p - a.str;
 130 }