lib/strstr.c

   1 /* Searching in a string.
   2    Copyright (C) 2005 Free Software Foundation, Inc.
   3    Written by Bruno Haible <bruno@clisp.org>, 2005.
   4
   5    This program is free software; you can redistribute it and/or modify
   6    it under the terms of the GNU General Public License as published by
   7    the Free Software Foundation; either version 2, or (at your option)
   8    any later version.
   9
  10    This program is distributed in the hope that it will be useful,
  11    but WITHOUT ANY WARRANTY; without even the implied warranty of
  12    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13    GNU General Public License for more details.
  14
  15    You should have received a copy of the GNU General Public License
  16    along with this program; if not, write to the Free Software Foundation,
  17    Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.  */
  18
  19 #ifdef HAVE_CONFIG_H
  20 # include <config.h>
  21 #endif
  22
  23 /* Specification.  */
  24 #include "strstr.h"
  25
  26 #include <stddef.h>  /* for NULL */
  27
  28 #if HAVE_MBRTOWC
  29 # include "mbuiter.h"
  30 #endif
  31
  32 /* Find the first occurrence of NEEDLE in HAYSTACK.  */
  33 char *
  34 strstr (const char *haystack, const char *needle)
  35 {
  36   /* Be careful not to look at the entire extent of haystack or needle
  37      until needed.  This is useful because of these two cases:
  38        - haystack may be very long, and a match of needle found early,
  39        - needle may be very long, and not even a short initial segment of
  40          needle may be found in haystack.  */
  41 #if HAVE_MBRTOWC
  42   if (MB_CUR_MAX > 1)
  43     {
  44       mbui_iterator_t iter_needle;
  45
  46       mbui_init (iter_needle, needle);
  47       if (mbui_avail (iter_needle))
  48         {
  49           mbui_iterator_t iter_haystack;
  50
  51           mbui_init (iter_haystack, haystack);
  52           for (;; mbui_advance (iter_haystack))
  53             {
  54               if (!mbui_avail (iter_haystack))
  55                 /* No match.  */
  56                 return NULL;
  57
  58               if (mb_equal (mbui_cur (iter_haystack), mbui_cur (iter_needle)))
  59                 /* The first character matches.  */
  60                 {
  61                   mbui_iterator_t rhaystack;
  62                   mbui_iterator_t rneedle;
  63
  64                   memcpy (&rhaystack, &iter_haystack, sizeof (mbui_iterator_t));
  65                   mbui_advance (rhaystack);
  66
  67                   mbui_init (rneedle, needle);
  68                   if (!mbui_avail (rneedle))
  69                     abort ();
  70                   mbui_advance (rneedle);
  71
  72                   for (;; mbui_advance (rhaystack), mbui_advance (rneedle))
  73                     {
  74                       if (!mbui_avail (rneedle))
  75                         /* Found a match.  */
  76                         return (char *) mbui_cur_ptr (iter_haystack);
  77                       if (!mbui_avail (rhaystack))
  78                         /* No match.  */
  79                         return NULL;
  80                       if (!mb_equal (mbui_cur (rhaystack), mbui_cur (rneedle)))
  81                         /* Nothing in this round.  */
  82                         break;
  83                     }
  84                 }
  85             }
  86         }
  87       else
  88         return (char *) haystack;
  89     }
  90   else
  91 #endif
  92     {
  93       if (*needle != '\0')
  94         {
  95           /* Speed up the following searches of needle by caching its first
  96              character.  */
  97           char b = *needle++;
  98
  99           for (;; haystack++)
 100             {
 101               if (*haystack == '\0')
 102                 /* No match.  */
 103                 return NULL;
 104               if (*haystack == b)
 105                 /* The first character matches.  */
 106                 {
 107                   const char *rhaystack = haystack + 1;
 108                   const char *rneedle = needle;
 109
 110                   for (;; rhaystack++, rneedle++)
 111                     {
 112                       if (*rneedle == '\0')
 113                         /* Found a match.  */
 114                         return (char *) haystack;
 115                       if (*rhaystack == '\0')
 116                         /* No match.  */
 117                         return NULL;
 118                       if (*rhaystack != *rneedle)
 119                         /* Nothing in this round.  */
 120                         break;
 121                     }
 122                 }
 123             }
 124         }
 125       else
 126         return (char *) haystack;
 127     }
 128 }