rugged 1.9.4 → 1.9.5.1

data/vendor/libgit2/deps/pcre2/pcre2_match_data.c

@@ -0,0 +1,184 @@
+/*************************************************
+*      Perl-Compatible Regular Expressions       *
+*************************************************/
+
+/* PCRE is a library of functions to support regular expressions whose syntax
+and semantics are as close as possible to those of the Perl 5 language.
+
+                       Written by Philip Hazel
+     Original API code Copyright (c) 1997-2012 University of Cambridge
+          New API code Copyright (c) 2016-2024 University of Cambridge
+
+-----------------------------------------------------------------------------
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+    * Redistributions of source code must retain the above copyright notice,
+      this list of conditions and the following disclaimer.
+
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+
+    * Neither the name of the University of Cambridge nor the names of its
+      contributors may be used to endorse or promote products derived from
+      this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGE.
+-----------------------------------------------------------------------------
+*/
+
+
+#include "pcre2_internal.h"
+
+
+
+/*************************************************
+*  Create a match data block given ovector size  *
+*************************************************/
+
+/* A minimum of 1 is imposed on the number of ovector pairs. A maximum is also
+imposed because the oveccount field in a match data block is uintt6_t. */
+
+PCRE2_EXP_DEFN pcre2_match_data * PCRE2_CALL_CONVENTION
+pcre2_match_data_create(uint32_t oveccount, pcre2_general_context *gcontext)
+{
+pcre2_match_data *yield;
+if (oveccount < 1) oveccount = 1;
+if (oveccount > UINT16_MAX) oveccount = UINT16_MAX;
+yield = PRIV(memctl_malloc)(
+  offsetof(pcre2_match_data, ovector) + 2*oveccount*sizeof(PCRE2_SIZE),
+  (pcre2_memctl *)gcontext);
+if (yield == NULL) return NULL;
+yield->oveccount = oveccount;
+yield->flags = 0;
+yield->heapframes = NULL;
+yield->heapframes_size = 0;
+return yield;
+}
+
+
+
+/*************************************************
+*  Create a match data block using pattern data  *
+*************************************************/
+
+/* If no context is supplied, use the memory allocator from the code. This code
+assumes that a general context contains nothing other than a memory allocator.
+If that ever changes, this code will need fixing. */
+
+PCRE2_EXP_DEFN pcre2_match_data * PCRE2_CALL_CONVENTION
+pcre2_match_data_create_from_pattern(const pcre2_code *code,
+  pcre2_general_context *gcontext)
+{
+if (code == NULL) return NULL;
+if (gcontext == NULL) gcontext = (pcre2_general_context *)code;
+return pcre2_match_data_create(((const pcre2_real_code *)code)->top_bracket + 1,
+  gcontext);
+}
+
+
+
+/*************************************************
+*            Free a match data block             *
+*************************************************/
+
+PCRE2_EXP_DEFN void PCRE2_CALL_CONVENTION
+pcre2_match_data_free(pcre2_match_data *match_data)
+{
+if (match_data != NULL)
+  {
+  if (match_data->heapframes != NULL)
+    match_data->memctl.free(match_data->heapframes,
+      match_data->memctl.memory_data);
+  if ((match_data->flags & PCRE2_MD_COPIED_SUBJECT) != 0)
+    match_data->memctl.free((void *)match_data->subject,
+      match_data->memctl.memory_data);
+  match_data->memctl.free(match_data, match_data->memctl.memory_data);
+  }
+}
+
+
+
+/*************************************************
+*         Get last mark in match                 *
+*************************************************/
+
+PCRE2_EXP_DEFN PCRE2_SPTR PCRE2_CALL_CONVENTION
+pcre2_get_mark(pcre2_match_data *match_data)
+{
+return match_data->mark;
+}
+
+
+
+/*************************************************
+*          Get pointer to ovector                *
+*************************************************/
+
+PCRE2_EXP_DEFN PCRE2_SIZE * PCRE2_CALL_CONVENTION
+pcre2_get_ovector_pointer(pcre2_match_data *match_data)
+{
+return match_data->ovector;
+}
+
+
+
+/*************************************************
+*          Get number of ovector slots           *
+*************************************************/
+
+PCRE2_EXP_DEFN uint32_t PCRE2_CALL_CONVENTION
+pcre2_get_ovector_count(pcre2_match_data *match_data)
+{
+return match_data->oveccount;
+}
+
+
+
+/*************************************************
+*         Get starting code unit in match        *
+*************************************************/
+
+PCRE2_EXP_DEFN PCRE2_SIZE PCRE2_CALL_CONVENTION
+pcre2_get_startchar(pcre2_match_data *match_data)
+{
+return match_data->startchar;
+}
+
+
+
+/*************************************************
+*         Get size of match data block           *
+*************************************************/
+
+PCRE2_EXP_DEFN PCRE2_SIZE PCRE2_CALL_CONVENTION
+pcre2_get_match_data_size(pcre2_match_data *match_data)
+{
+return offsetof(pcre2_match_data, ovector) +
+  2 * (match_data->oveccount) * sizeof(PCRE2_SIZE);
+}
+
+
+
+/*************************************************
+*             Get heapframes size                *
+*************************************************/
+
+PCRE2_EXP_DEFN PCRE2_SIZE PCRE2_CALL_CONVENTION
+pcre2_get_match_data_heapframes_size(pcre2_match_data *match_data)
+{
+return match_data->heapframes_size;
+}
+
+/* End of pcre2_match_data.c */

data/vendor/libgit2/deps/pcre2/pcre2_match_next.c

@@ -0,0 +1,171 @@
+/*************************************************
+*      Perl-Compatible Regular Expressions       *
+*************************************************/
+
+/* PCRE is a library of functions to support regular expressions whose syntax
+and semantics are as close as possible to those of the Perl 5 language.
+
+                       Written by Philip Hazel
+     Original API code Copyright (c) 1997-2012 University of Cambridge
+          New API code Copyright (c) 2016-2024 University of Cambridge
+
+-----------------------------------------------------------------------------
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+    * Redistributions of source code must retain the above copyright notice,
+      this list of conditions and the following disclaimer.
+
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+
+    * Neither the name of the University of Cambridge nor the names of its
+      contributors may be used to endorse or promote products derived from
+      this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGE.
+-----------------------------------------------------------------------------
+*/
+
+
+#include "pcre2_internal.h"
+
+
+
+/* Advance the offset by one code unit, and return the new value.
+It is only called when the offset is not at the end of the subject. */
+
+static PCRE2_SIZE do_bumpalong(pcre2_match_data *match_data,
+  PCRE2_SIZE offset)
+{
+PCRE2_SPTR subject = match_data->subject;
+PCRE2_SIZE subject_length = match_data->subject_length;
+#ifdef SUPPORT_UNICODE
+BOOL utf = (match_data->code->overall_options & PCRE2_UTF) != 0;
+#endif
+
+/* Skip over CRLF as an atomic sequence, if CRLF is configured as a newline
+sequence. */
+
+if (subject[offset] == CHAR_CR && offset + 1 < subject_length &&
+    subject[offset + 1] == CHAR_LF)
+  {
+  switch(match_data->code->newline_convention)
+    {
+    case PCRE2_NEWLINE_CRLF:
+    case PCRE2_NEWLINE_ANY:
+    case PCRE2_NEWLINE_ANYCRLF:
+    return offset + 2;
+    }
+  }
+
+/* Advance by one full character if in UTF mode. */
+
+#ifdef SUPPORT_UNICODE
+if (utf)
+  {
+  PCRE2_SPTR next = subject + offset + 1;
+  PCRE2_SPTR subject_end = subject + subject_length;
+
+  (void)subject_end; /* Suppress warning; 32-bit FORWARDCHARTEST ignores this */
+  FORWARDCHARTEST(next, subject_end);
+  return next - subject;
+  }
+#endif
+
+return offset + 1;
+}
+
+
+
+/*************************************************
+*                Advance the match               *
+*************************************************/
+
+PCRE2_EXP_DEFN int PCRE2_CALL_CONVENTION
+pcre2_next_match(pcre2_match_data *match_data, PCRE2_SIZE *pstart_offset,
+  uint32_t *poptions)
+{
+int rc = match_data->rc;
+PCRE2_SIZE start_offset = match_data->start_offset;
+PCRE2_SIZE *ovector = match_data->ovector;
+
+/* Match error, or no match: no further iteration possible. In previous versions
+of PCRE2, we recommended that clients use a strategy which involved retrying in
+certain cases after PCRE2_ERROR_NOMATCH, but this is no longer required. */
+
+if (rc < 0)
+  return FALSE;
+
+/* Match succeeded: get the start offset for the next match */
+
+/* Although \K can affect the position of ovector[0], there are no ways to do
+anything surprising with ovector[1], which must always be >= start_offset. */
+
+PCRE2_ASSERT(ovector[1] >= start_offset);
+
+/* Special handling for patterns which contain \K in a lookaround, which enables
+the match start to be pushed back to before the starting search offset
+(ovector[0] < start_offset) or after the match ends (ovector[0] > ovector[1]).
+This is not a problem if ovector[1] > start_offset, because in this case, we can
+just attempt the next match at ovector[1]: we are making progress, which is all
+that we require.
+
+However, if we have ovector[1] == start_offset, then we have a very rare case
+which must be handled specially, because it's a non-empty match which
+nonetheless fails to make progress through the subject. */
+
+if (ovector[0] != start_offset && ovector[1] == start_offset)
+  {
+  /* If the match end is at the end of the subject, we are done. */
+
+  if (start_offset >= match_data->subject_length)
+    return FALSE;
+
+  /* Otherwise, bump along by one code unit, and do a normal search. */
+
+  *pstart_offset = do_bumpalong(match_data, ovector[1]);
+  *poptions = 0;
+  return TRUE;
+  }
+
+/* If the previous match was for an empty string, we are finished if we are at
+the end of the subject. Otherwise, arrange to run another match at the same
+point to see if a non-empty match can be found. */
+
+if (ovector[0] == ovector[1])
+  {
+  /* If the match is at the end of the subject, we are done. */
+
+  if (ovector[0] >= match_data->subject_length)
+    return FALSE;
+
+  /* Otherwise, continue at this exact same point, but we must set the flag
+  which ensures that we don't return the exact same empty match again. */
+
+  *pstart_offset = ovector[1];
+  *poptions = PCRE2_NOTEMPTY_ATSTART;
+  return TRUE;
+  }
+
+/* Finally, we must be in the happy state of a non-empty match, where the end of
+the match is further on in the subject than start_offset, so we are easily able
+to continue and make progress. */
+
+*pstart_offset = ovector[1];
+*poptions = 0;
+return TRUE;
+}
+
+/* End of pcre2_match_next.c */

data/vendor/libgit2/deps/{pcre/pcre_newline.c → pcre2/pcre2_newline.c}

@@ -6,7 +6,8 @@
 and semantics are as close as possible to those of the Perl 5 language.
 
                        Written by Philip Hazel
-           Copyright (c) 1997-2012 University of Cambridge
+     Original API code Copyright (c) 1997-2012 University of Cambridge
+         New API code Copyright (c) 2016 University of Cambridge
 
 -----------------------------------------------------------------------------
 Redistribution and use in source and binary forms, with or without
@@ -41,17 +42,13 @@ POSSIBILITY OF SUCH DAMAGE.
 /* This module contains internal functions for testing newlines when more than
 one kind of newline is to be recognized. When a newline is found, its length is
 returned. In principle, we could implement several newline "types", each
-referring to a different set of newline characters. At present, PCRE supports
+referring to a different set of newline characters. At present, PCRE2 supports
 only NLTYPE_FIXED, which gets handled without these functions, NLTYPE_ANYCRLF,
 and NLTYPE_ANY. The full list of Unicode newline characters is taken from
 http://unicode.org/unicode/reports/tr18/. */
 
 
-#ifdef HAVE_CONFIG_H
-#include "config.h"
-#endif
-
-#include "pcre_internal.h"
+#include "pcre2_internal.h"
 
 
 
@@ -59,8 +56,10 @@ http://unicode.org/unicode/reports/tr18/. */
 *      Check for newline at given position       *
 *************************************************/
 
-/* It is guaranteed that the initial value of ptr is less than the end of the
-string that is being processed.
+/* This function is called only via the IS_NEWLINE macro, which does so only
+when the newline type is NLTYPE_ANY or NLTYPE_ANYCRLF. The case of a fixed
+newline (NLTYPE_FIXED) is handled inline. It is guaranteed that the code unit
+pointed to by ptr is less than the end of the string.
 
 Arguments:
   ptr          pointer to possible newline
@@ -73,28 +72,30 @@ Returns:       TRUE or FALSE
 */
 
 BOOL
-PRIV(is_newline)(PCRE_PUCHAR ptr, int type, PCRE_PUCHAR endptr, int *lenptr,
-  BOOL utf)
+PRIV(is_newline)(PCRE2_SPTR ptr, uint32_t type, PCRE2_SPTR endptr,
+  uint32_t *lenptr, BOOL utf)
 {
-pcre_uint32 c;
-(void)utf;
-#ifdef SUPPORT_UTF
-if (utf)
-  {
-  GETCHAR(c, ptr);
-  }
-else
-#endif  /* SUPPORT_UTF */
-  c = *ptr;
+uint32_t c;
 
-/* Note that this function is called only for ANY or ANYCRLF. */
+#ifdef SUPPORT_UNICODE
+if (utf) { GETCHAR(c, ptr); } else c = *ptr;
+#else
+(void)utf;
+c = *ptr;
+#endif  /* SUPPORT_UNICODE */
 
 if (type == NLTYPE_ANYCRLF) switch(c)
   {
-  case CHAR_LF: *lenptr = 1; return TRUE;
-  case CHAR_CR: *lenptr = (ptr < endptr - 1 && ptr[1] == CHAR_LF)? 2 : 1;
-               return TRUE;
-  default: return FALSE;
+  case CHAR_LF:
+  *lenptr = 1;
+  return TRUE;
+
+  case CHAR_CR:
+  *lenptr = (ptr < endptr - 1 && ptr[1] == CHAR_LF)? 2 : 1;
+  return TRUE;
+
+  default:
+  return FALSE;
   }
 
 /* NLTYPE_ANY */
@@ -106,25 +107,36 @@ else switch(c)
 #endif
   case CHAR_LF:
   case CHAR_VT:
-  case CHAR_FF: *lenptr = 1; return TRUE;
+  case CHAR_FF:
+  *lenptr = 1;
+  return TRUE;
 
   case CHAR_CR:
   *lenptr = (ptr < endptr - 1 && ptr[1] == CHAR_LF)? 2 : 1;
   return TRUE;
 
 #ifndef EBCDIC
-#ifdef COMPILE_PCRE8
-  case CHAR_NEL: *lenptr = utf? 2 : 1; return TRUE;
-  case 0x2028:                                       /* LS */
-  case 0x2029: *lenptr = 3; return TRUE;             /* PS */
-#else /* COMPILE_PCRE16 || COMPILE_PCRE32 */
+#if PCRE2_CODE_UNIT_WIDTH == 8
+  case CHAR_NEL:
+  *lenptr = utf? 2 : 1;
+  return TRUE;
+
+  case 0x2028:   /* LS */
+  case 0x2029:   /* PS */
+  *lenptr = 3;
+  return TRUE;
+
+#else  /* 16-bit or 32-bit code units */
   case CHAR_NEL:
-  case 0x2028:                                       /* LS */
-  case 0x2029: *lenptr = 1; return TRUE;             /* PS */
-#endif  /* COMPILE_PCRE8 */
-#endif  /* Not EBCDIC */
+  case 0x2028:   /* LS */
+  case 0x2029:   /* PS */
+  *lenptr = 1;
+  return TRUE;
+#endif
+#endif /* Not EBCDIC */
 
-  default: return FALSE;
+  default:
+  return FALSE;
   }
 }
 
@@ -134,8 +146,10 @@ else switch(c)
 *     Check for newline at previous position     *
 *************************************************/
 
-/* It is guaranteed that the initial value of ptr is greater than the start of
-the string that is being processed.
+/* This function is called only via the WAS_NEWLINE macro, which does so only
+when the newline type is NLTYPE_ANY or NLTYPE_ANYCRLF. The case of a fixed
+newline (NLTYPE_FIXED) is handled inline. It is guaranteed that the initial
+value of ptr is greater than the start of the string that is being processed.
 
 Arguments:
   ptr          pointer to possible newline
@@ -148,23 +162,23 @@ Returns:       TRUE or FALSE
 */
 
 BOOL
-PRIV(was_newline)(PCRE_PUCHAR ptr, int type, PCRE_PUCHAR startptr, int *lenptr,
-  BOOL utf)
+PRIV(was_newline)(PCRE2_SPTR ptr, uint32_t type, PCRE2_SPTR startptr,
+  uint32_t *lenptr, BOOL utf)
 {
-pcre_uint32 c;
-(void)utf;
+uint32_t c;
 ptr--;
-#ifdef SUPPORT_UTF
+
+#ifdef SUPPORT_UNICODE
 if (utf)
   {
   BACKCHAR(ptr);
   GETCHAR(c, ptr);
   }
-else
-#endif  /* SUPPORT_UTF */
-  c = *ptr;
-
-/* Note that this function is called only for ANY or ANYCRLF. */
+else c = *ptr;
+#else
+(void)utf;
+c = *ptr;
+#endif  /* SUPPORT_UNICODE */
 
 if (type == NLTYPE_ANYCRLF) switch(c)
   {
@@ -172,8 +186,12 @@ if (type == NLTYPE_ANYCRLF) switch(c)
   *lenptr = (ptr > startptr && ptr[-1] == CHAR_CR)? 2 : 1;
   return TRUE;
 
-  case CHAR_CR: *lenptr = 1; return TRUE;
-  default: return FALSE;
+  case CHAR_CR:
+  *lenptr = 1;
+  return TRUE;
+
+  default:
+  return FALSE;
   }
 
 /* NLTYPE_ANY */
@@ -189,22 +207,33 @@ else switch(c)
 #endif
   case CHAR_VT:
   case CHAR_FF:
-  case CHAR_CR: *lenptr = 1; return TRUE;
+  case CHAR_CR:
+  *lenptr = 1;
+  return TRUE;
 
 #ifndef EBCDIC
-#ifdef COMPILE_PCRE8
-  case CHAR_NEL: *lenptr = utf? 2 : 1; return TRUE;
-  case 0x2028:                                       /* LS */
-  case 0x2029: *lenptr = 3; return TRUE;             /* PS */
-#else /* COMPILE_PCRE16 || COMPILE_PCRE32 */
+#if PCRE2_CODE_UNIT_WIDTH == 8
+  case CHAR_NEL:
+  *lenptr = utf? 2 : 1;
+  return TRUE;
+
+  case 0x2028:   /* LS */
+  case 0x2029:   /* PS */
+  *lenptr = 3;
+  return TRUE;
+
+#else /* 16-bit or 32-bit code units */
   case CHAR_NEL:
-  case 0x2028:                                       /* LS */
-  case 0x2029: *lenptr = 1; return TRUE;             /* PS */
-#endif  /* COMPILE_PCRE8 */
-#endif  /* NotEBCDIC */
+  case 0x2028:   /* LS */
+  case 0x2029:   /* PS */
+  *lenptr = 1;
+  return TRUE;
+#endif
+#endif /* Not EBCDIC */
 
-  default: return FALSE;
+  default:
+  return FALSE;
   }
 }
 
-/* End of pcre_newline.c */
+/* End of pcre2_newline.c */