/* pcresearch.c - searching subroutines using PCRE for grep.

   Copyright 2000, 2007, 2009-2017 Free Software Foundation, Inc.

   This program is free software; you can redistribute it and/or modify

   it under the terms of the GNU General Public License as published by

   the Free Software Foundation; either version 3, or (at your option)

   any later version.

   This program is distributed in the hope that it will be useful,

   but WITHOUT ANY WARRANTY; without even the implied warranty of

   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License

   along with this program; if not, write to the Free Software

   Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA

   02110-1301, USA.  */

/* Written August 1992 by Mike Haertel. */

#include <config.h>

#include "search.h"

#include "die.h"

#if HAVE_LIBPCRE

# include <pcre.h>

/* This must be at least 2; everything after that is for performance

   in pcre_exec.  */

enum { NSUB = 300 };

# ifndef PCRE_STUDY_JIT_COMPILE

#  define PCRE_STUDY_JIT_COMPILE 0

# endif

struct pcre_comp

{

  /* Compiled internal form of a Perl regular expression.  */

  pcre *cre;

  /* Additional information about the pattern.  */

  pcre_extra *extra;

# if PCRE_STUDY_JIT_COMPILE

  /* The JIT stack and its maximum size.  */

  pcre_jit_stack *jit_stack;

  int jit_stack_size;

# endif

  /* Table, indexed by ! (flag & PCRE_NOTBOL), of whether the empty

     string matches when that flag is used.  */

  int empty_match[2];

};

/* Match the already-compiled PCRE pattern against the data in SUBJECT,

   of size SEARCH_BYTES and starting with offset SEARCH_OFFSET, with

   options OPTIONS, and storing resulting matches into SUB.  Return

   the (nonnegative) match location or a (negative) error number.  */

static int

jit_exec (struct pcre_comp *pc, char const *subject, int search_bytes,

          int search_offset, int options, int *sub)

{

  while (true)

    {

      int e = pcre_exec (pc->cre, pc->extra, subject, search_bytes,

                         search_offset, options, sub, NSUB);

# if PCRE_STUDY_JIT_COMPILE

      if (e == PCRE_ERROR_JIT_STACKLIMIT

          && 0 < pc->jit_stack_size && pc->jit_stack_size <= INT_MAX / 2)

        {

          int old_size = pc->jit_stack_size;

          int new_size = pc->jit_stack_size = old_size * 2;

          if (pc->jit_stack)

            pcre_jit_stack_free (pc->jit_stack);

          pc->jit_stack = pcre_jit_stack_alloc (old_size, new_size);

          if (!pc->jit_stack)

            die (EXIT_TROUBLE, 0,

                 _("failed to allocate memory for the PCRE JIT stack"));

          pcre_assign_jit_stack (pc->extra, NULL, pc->jit_stack);

          continue;

        }

# endif

      return e;

    }

}

#endif

void *

Pcompile (char *pattern, size_t size, reg_syntax_t ignored)

{

#if !HAVE_LIBPCRE

  die (EXIT_TROUBLE, 0,

       _("support for the -P option is not compiled into "

         "this --disable-perl-regexp binary"));

#else

  int e;

  char const *ep;

  static char const wprefix[] = "(?

  static char const wsuffix[] = ")(?!\\w)";

  static char const xprefix[] = "^(?:";

  static char const xsuffix[] = ")$";

  int fix_len_max = MAX (sizeof wprefix - 1 + sizeof wsuffix - 1,

                         sizeof xprefix - 1 + sizeof xsuffix - 1);

  char *re = xnmalloc (4, size + (fix_len_max + 4 - 1) / 4);

  int flags = PCRE_DOLLAR_ENDONLY | (match_icase ? PCRE_CASELESS : 0);

  char const *patlim = pattern + size;

  char *n = re;

  char const *p;

  char const *pnul;

  struct pcre_comp *pc = xcalloc (1, sizeof (*pc));

  if (localeinfo.multibyte)

    {

      if (! localeinfo.using_utf8)

        die (EXIT_TROUBLE, 0, _("-P supports only unibyte and UTF-8 locales"));

      flags |= PCRE_UTF8;

    }

  /* FIXME: Remove this restriction.  */

  if (memchr (pattern, '\n', size))

    die (EXIT_TROUBLE, 0, _("the -P option only supports a single pattern"));

  *n = '\0';

  if (match_words)

    strcpy (n, wprefix);

  if (match_lines)

    strcpy (n, xprefix);

  n += strlen (n);

  /* The PCRE interface doesn't allow NUL bytes in the pattern, so

     replace each NUL byte in the pattern with the four characters

     "\000", removing a preceding backslash if there are an odd

     number of backslashes before the NUL.  */

  for (p = pattern; (pnul = memchr (p, '\0', patlim - p)); p = pnul + 1)

    {

      memcpy (n, p, pnul - p);

      n += pnul - p;

      for (p = pnul; pattern < p && p[-1] == '\\'; p--)

        continue;

      n -= (pnul - p) & 1;

      strcpy (n, "\\000");

      n += 4;

    }

  memcpy (n, p, patlim - p);

  n += patlim - p;

  *n = '\0';

  if (match_words)

    strcpy (n, wsuffix);

  if (match_lines)

    strcpy (n, xsuffix);

  pc->cre = pcre_compile (re, flags, &ep, &e, pcre_maketables ());

  if (!pc->cre)

    die (EXIT_TROUBLE, 0, "%s", ep);

  pc->extra = pcre_study (pc->cre, PCRE_STUDY_JIT_COMPILE, &ep);

  if (ep)

    die (EXIT_TROUBLE, 0, "%s", ep);

# if PCRE_STUDY_JIT_COMPILE

  if (pcre_fullinfo (pc->cre, pc->extra, PCRE_INFO_JIT, &e))

    die (EXIT_TROUBLE, 0, _("internal error (should never happen)"));

  /* The PCRE documentation says that a 32 KiB stack is the default.  */

  if (e)

    pc->jit_stack_size = 32 << 10;

# endif

  free (re);

  int sub[NSUB];

  pc->empty_match[false] = pcre_exec (pc->cre, pc->extra, "", 0, 0,

                                      PCRE_NOTBOL, sub, NSUB);

  pc->empty_match[true] = pcre_exec (pc->cre, pc->extra, "", 0, 0, 0, sub,

                                     NSUB);

  return pc;

#endif /* HAVE_LIBPCRE */

}

size_t

Pexecute (void *vcp, char const *buf, size_t size, size_t *match_size,

          char const *start_ptr)

{

#if !HAVE_LIBPCRE

  /* We can't get here, because Pcompile would have been called earlier.  */

  die (EXIT_TROUBLE, 0, _("internal error"));

#else

  int sub[NSUB];

  char const *p = start_ptr ? start_ptr : buf;

  bool bol = p[-1] == eolbyte;

  char const *line_start = buf;

  int e = PCRE_ERROR_NOMATCH;

  char const *line_end;

  struct pcre_comp *pc = vcp;

  /* The search address to pass to pcre_exec.  This is the start of

     the buffer, or just past the most-recently discovered encoding

     error or line end.  */

  char const *subject = buf;

  do

    {

      /* Search line by line.  Although this code formerly used

         PCRE_MULTILINE for performance, the performance wasn't always

         better and the correctness issues were too puzzling.  See

         Bug#22655.  */

      line_end = memchr (p, eolbyte, buf + size - p);

      if (INT_MAX < line_end - p)

        die (EXIT_TROUBLE, 0, _("exceeded PCRE's line length limit"));

      for (;;)

        {

          /* Skip past bytes that are easily determined to be encoding

             errors, treating them as data that cannot match.  This is

             faster than having pcre_exec check them.  */

          while (localeinfo.sbclen[to_uchar (*p)] == -1)

            {

              p++;

              subject = p;

              bol = false;

            }

          int search_offset = p - subject;

          /* Check for an empty match; this is faster than letting

             pcre_exec do it.  */

          if (p == line_end)

            {

              sub[0] = sub[1] = search_offset;

              e = pc->empty_match[bol];

              break;

            }

          int options = 0;

          if (!bol)

            options |= PCRE_NOTBOL;

          e = jit_exec (pc, subject, line_end - subject, search_offset,

                        options, sub);

          if (e != PCRE_ERROR_BADUTF8)

            break;

          int valid_bytes = sub[0];

          if (search_offset <= valid_bytes)

            {

              /* Try to match the string before the encoding error.  */

              if (valid_bytes == 0)

                {

                  /* Handle the empty-match case specially, for speed.

                     This optimization is valid if VALID_BYTES is zero,

                     which means SEARCH_OFFSET is also zero.  */

                  sub[1] = 0;

                  e = pc->empty_match[bol];

                }

              else

                e = jit_exec (pc, subject, valid_bytes, search_offset,

                              options | PCRE_NO_UTF8_CHECK | PCRE_NOTEOL, sub);

              if (e != PCRE_ERROR_NOMATCH)

                break;

              /* Treat the encoding error as data that cannot match.  */

              p = subject + valid_bytes + 1;

              bol = false;

            }

          subject += valid_bytes + 1;

        }

      if (e != PCRE_ERROR_NOMATCH)

        break;

      bol = true;

      p = subject = line_start = line_end + 1;

    }

  while (p < buf + size);

  if (e <= 0)

    {

      switch (e)

        {

        case PCRE_ERROR_NOMATCH:

          break;

        case PCRE_ERROR_NOMEMORY:

          die (EXIT_TROUBLE, 0, _("memory exhausted"));

# if PCRE_STUDY_JIT_COMPILE

        case PCRE_ERROR_JIT_STACKLIMIT:

          die (EXIT_TROUBLE, 0, _("exhausted PCRE JIT stack"));

# endif

        case PCRE_ERROR_MATCHLIMIT:

          die (EXIT_TROUBLE, 0, _("exceeded PCRE's backtracking limit"));

        default:

          /* For now, we lump all remaining PCRE failures into this basket.

             If anyone cares to provide sample grep usage that can trigger

             particular PCRE errors, we can add to the list (above) of more

             detailed diagnostics.  */

          die (EXIT_TROUBLE, 0, _("internal PCRE error: %d"), e);

        }

      return -1;

    }

  else

    {

      char const *matchbeg = subject + sub[0];

      char const *matchend = subject + sub[1];

      char const *beg;

      char const *end;

      if (start_ptr)

        {

          beg = matchbeg;

          end = matchend;

        }

      else

        {

          beg = line_start;

          end = line_end + 1;

        }

      *match_size = end - beg;

      return beg - buf;

    }

#endif

}