[T106][ZXW-22]7520V3SCV2.01.01.02P42U09_VEC_V0.8_AP_VEC origin source commit
Change-Id: Ic6e05d89ecd62fc34f82b23dcf306c93764aec4b
diff --git a/ap/libc/glibc/glibc-2.22/misc/regexp.h b/ap/libc/glibc/glibc-2.22/misc/regexp.h
new file mode 100644
index 0000000..3460989
--- /dev/null
+++ b/ap/libc/glibc/glibc-2.22/misc/regexp.h
@@ -0,0 +1,229 @@
+/* Copyright (C) 1996-2015 Free Software Foundation, Inc.
+ This file is part of the GNU C Library.
+ Contributed by Ulrich Drepper <drepper@cygnus.com>, 1996.
+
+ The GNU C Library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Lesser General Public
+ License as published by the Free Software Foundation; either
+ version 2.1 of the License, or (at your option) any later version.
+
+ The GNU C Library 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
+ Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with the GNU C Library; if not, see
+ <http://www.gnu.org/licenses/>. */
+
+#ifndef _REGEXP_H
+#define _REGEXP_H 1
+
+/* The contents of this header file were standardized in the
+ Single Unix Specification, Version 2 (1997) but marked as
+ LEGACY; new applications were already being encouraged to
+ use <regex.h> instead. POSIX.1-2001 removed this header.
+
+ This header is provided only for backward compatibility.
+ It will be removed in the next release of the GNU C Library.
+ New code should use <regex.h> instead. */
+
+#warning "<regexp.h> will be removed in the next release of the GNU C Library."
+#warning "Please update your code to use <regex.h> instead (no trailing 'p')."
+
+#include <features.h>
+#include <alloca.h>
+#include <regex.h>
+#include <stdlib.h>
+#include <string.h>
+
+/* The implementation provided here emulates the needed functionality
+ by mapping to the POSIX regular expression matcher. The interface
+ for the here included function is weird (this really is a harmless
+ word).
+
+ The user has to provide six macros before this header file can be
+ included:
+
+ INIT Declarations vor variables which can be used by the
+ other macros.
+
+ GETC() Return the value of the next character in the regular
+ expression pattern. Successive calls should return
+ successive characters.
+
+ PEEKC() Return the value of the next character in the regular
+ expression pattern. Immediately successive calls to
+ PEEKC() should return the same character which should
+ also be the next character returned by GETC().
+
+ UNGETC(c) Cause `c' to be returned by the next call to GETC() and
+ PEEKC().
+
+ RETURN(ptr) Used for normal exit of the `compile' function. `ptr'
+ is a pointer to the character after the last character of
+ the compiled regular expression.
+
+ ERROR(val) Used for abnormal return from `compile'. `val' is the
+ error number. The error codes are:
+ 11 Range endpoint too large.
+ 16 Bad number.
+ 25 \digit out of range.
+ 36 Illegal or missing delimiter.
+ 41 No remembered search string.
+ 42 \( \) imbalance.
+ 43 Too many \(.
+ 44 More tan two numbers given in \{ \}.
+ 45 } expected after \.
+ 46 First number exceeds second in \{ \}.
+ 49 [ ] imbalance.
+ 50 Regular expression overflow.
+
+ */
+
+__BEGIN_DECLS
+
+/* Interface variables. They contain the results of the successful
+ calls to `setp' and `advance'. */
+extern char *loc1;
+extern char *loc2;
+
+/* The use of this variable in the `advance' function is not
+ supported. */
+extern char *locs;
+
+
+#ifndef __DO_NOT_DEFINE_COMPILE
+/* Get and compile the user supplied pattern up to end of line or
+ string or until EOF is seen, whatever happens first. The result is
+ placed in the buffer starting at EXPBUF and delimited by ENDBUF.
+
+ This function cannot be defined in the libc itself since it depends
+ on the macros. */
+char *
+compile (char *__restrict instring, char *__restrict expbuf,
+ const char *__restrict endbuf, int eof)
+{
+ char *__input_buffer = NULL;
+ size_t __input_size = 0;
+ size_t __current_size = 0;
+ int __ch;
+ int __error;
+ INIT
+
+ /* Align the expression buffer according to the needs for an object
+ of type `regex_t'. Then check for minimum size of the buffer for
+ the compiled regular expression. */
+ regex_t *__expr_ptr;
+# if defined __GNUC__ && __GNUC__ >= 2
+ const size_t __req = __alignof__ (regex_t *);
+# else
+ /* How shall we find out? We simply guess it and can change it is
+ this really proofs to be wrong. */
+ const size_t __req = 8;
+# endif
+ expbuf += __req;
+ expbuf -= (expbuf - ((char *) 0)) % __req;
+ if (endbuf < expbuf + sizeof (regex_t))
+ {
+ ERROR (50);
+ }
+ __expr_ptr = (regex_t *) expbuf;
+ /* The remaining space in the buffer can be used for the compiled
+ pattern. */
+ __expr_ptr->__REPB_PREFIX (buffer) = expbuf + sizeof (regex_t);
+ __expr_ptr->__REPB_PREFIX (allocated)
+ = endbuf - (char *) __expr_ptr->__REPB_PREFIX (buffer);
+
+ while ((__ch = (GETC ())) != eof)
+ {
+ if (__ch == '\0' || __ch == '\n')
+ {
+ UNGETC (__ch);
+ break;
+ }
+
+ if (__current_size + 1 >= __input_size)
+ {
+ size_t __new_size = __input_size ? 2 * __input_size : 128;
+ char *__new_room = (char *) alloca (__new_size);
+ /* See whether we can use the old buffer. */
+ if (__new_room + __new_size == __input_buffer)
+ {
+ __input_size += __new_size;
+ __input_buffer = (char *) memcpy (__new_room, __input_buffer,
+ __current_size);
+ }
+ else if (__input_buffer + __input_size == __new_room)
+ __input_size += __new_size;
+ else
+ {
+ __input_size = __new_size;
+ __input_buffer = (char *) memcpy (__new_room, __input_buffer,
+ __current_size);
+ }
+ }
+ __input_buffer[__current_size++] = __ch;
+ }
+ if (__current_size)
+ __input_buffer[__current_size++] = '\0';
+ else
+ __input_buffer = "";
+
+ /* Now compile the pattern. */
+ __error = regcomp (__expr_ptr, __input_buffer, REG_NEWLINE);
+ if (__error != 0)
+ /* Oh well, we have to translate POSIX error codes. */
+ switch (__error)
+ {
+ case REG_BADPAT:
+ case REG_ECOLLATE:
+ case REG_ECTYPE:
+ case REG_EESCAPE:
+ case REG_BADRPT:
+ case REG_EEND:
+ case REG_ERPAREN:
+ default:
+ /* There is no matching error code. */
+ ERROR (36);
+ case REG_ESUBREG:
+ ERROR (25);
+ case REG_EBRACK:
+ ERROR (49);
+ case REG_EPAREN:
+ ERROR (42);
+ case REG_EBRACE:
+ ERROR (44);
+ case REG_BADBR:
+ ERROR (46);
+ case REG_ERANGE:
+ ERROR (11);
+ case REG_ESPACE:
+ case REG_ESIZE:
+ ERROR (50);
+ }
+
+ /* Everything is ok. */
+ RETURN ((char *) (__expr_ptr->__REPB_PREFIX (buffer)
+ + __expr_ptr->__REPB_PREFIX (used)));
+}
+#endif
+
+
+/* Find the next match in STRING. The compiled regular expression is
+ found in the buffer starting at EXPBUF. `loc1' will return the
+ first character matched and `loc2' points to the next unmatched
+ character. */
+extern int step (const char *__restrict __string,
+ const char *__restrict __expbuf) __THROW;
+
+/* Match the beginning of STRING with the compiled regular expression
+ in EXPBUF. If the match is successful `loc2' will contain the
+ position of the first unmatched character. */
+extern int advance (const char *__restrict __string,
+ const char *__restrict __expbuf) __THROW;
+
+
+__END_DECLS
+
+#endif /* regexp.h */