feat:replace boost library with C++11 std library

2020-04-01 20:53:55 +08:00
parent 6d06233944
commit d3258bbd97
1936 changed files with 241862 additions and 60153 deletions
@@ -0,0 +1,309 @@
+/*
+ * Copyright (c) 1987, 1993, 1994
+ *      The Regents of the University of California.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. 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.
+ * 3. All advertising materials mentioning features or use of this software
+ *    must display the following acknowledgement:
+ *      This product includes software developed by the University of
+ *      California, Berkeley and its contributors.
+ * 4. Neither the name of the University 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 REGENTS 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 REGENTS 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 "apr_arch_misc.h"
+#include "apr_strings.h"
+#include "apr_lib.h"
+
+#define EMSG    ""
+
+APR_DECLARE(apr_status_t) apr_getopt_init(apr_getopt_t **os, apr_pool_t *cont,
+                                      int argc, const char *const *argv)
+{
+    void *argv_buff;
+
+    *os = apr_palloc(cont, sizeof(apr_getopt_t));
+    (*os)->cont = cont;
+    (*os)->reset = 0;
+    (*os)->errfn = (apr_getopt_err_fn_t*)(fprintf);
+    (*os)->errarg = (void*)(stderr);
+
+    (*os)->place = EMSG;
+    (*os)->argc = argc;
+
+    /* The argv parameter must be compatible with main()'s argv, since
+       that's the primary purpose of this function.  But people might
+       want to use this function with arrays other than the main argv,
+       and we shouldn't touch the caller's data.  So we copy. */
+    argv_buff = apr_palloc(cont, (argc + 1) * sizeof(const char *));
+    memcpy(argv_buff, argv, argc * sizeof(const char *));
+    (*os)->argv = argv_buff;
+    (*os)->argv[argc] = NULL;
+
+    (*os)->interleave = 0;
+    (*os)->ind = 1;
+    (*os)->skip_start = 1;
+    (*os)->skip_end = 1;
+
+    return APR_SUCCESS;
+}
+
+APR_DECLARE(apr_status_t) apr_getopt(apr_getopt_t *os, const char *opts, 
+                                     char *optch, const char **optarg)
+{
+    const char *oli;  /* option letter list index */
+
+    if (os->reset || !*os->place) {   /* update scanning pointer */
+        os->reset = 0;
+        if (os->ind >= os->argc || *(os->place = os->argv[os->ind]) != '-') {
+            os->place = EMSG;
+            *optch = os->opt;
+            return (APR_EOF);
+        }
+        if (os->place[1] && *++os->place == '-') {        /* found "--" */
+            ++os->ind;
+            os->place = EMSG;
+            *optch = os->opt;
+            return (APR_EOF);
+        }
+    }                                /* option letter okay? */
+    if ((os->opt = (int) *os->place++) == (int) ':' ||
+        !(oli = strchr(opts, os->opt))) {
+        /*
+         * if the user didn't specify '-' as an option,
+         * assume it means -1.
+         */
+        if (os->opt == (int) '-') {
+            *optch = os->opt;
+            return (APR_EOF);
+        }
+        if (!*os->place)
+            ++os->ind;
+        if (os->errfn && *opts != ':') {
+            (os->errfn)(os->errarg, "%s: illegal option -- %c\n",
+                        apr_filepath_name_get(*os->argv), os->opt);
+        }
+        *optch = os->opt;
+        return (APR_BADCH);
+    }
+    if (*++oli != ':') {        /* don't need argument */
+        *optarg = NULL;
+        if (!*os->place)
+            ++os->ind;
+    }
+    else {                        /* need an argument */
+        if (*os->place)                /* no white space */
+            *optarg = os->place;
+        else if (os->argc <= ++os->ind) {        /* no arg */
+            os->place = EMSG;
+            if (*opts == ':') {
+                *optch = os->opt;
+                return (APR_BADARG);
+            }
+            if (os->errfn) {
+                (os->errfn)(os->errarg, 
+                            "%s: option requires an argument -- %c\n",
+                            apr_filepath_name_get(*os->argv), os->opt);
+            }
+            *optch = os->opt;
+            return (APR_BADCH);
+        }
+        else                        /* white space */
+            *optarg = os->argv[os->ind];
+        os->place = EMSG;
+        ++os->ind;
+    }
+    *optch = os->opt;
+    return APR_SUCCESS;
+}
+
+/* Reverse the sequence argv[start..start+len-1]. */
+static void reverse(const char **argv, int start, int len)
+{
+    const char *temp;
+
+    for (; len >= 2; start++, len -= 2) {
+        temp = argv[start];
+        argv[start] = argv[start + len - 1];
+        argv[start + len - 1] = temp;
+    }
+}
+
+/*
+ * Permute os->argv with the goal that non-option arguments will all
+ * appear at the end.  os->skip_start is where we started skipping
+ * non-option arguments, os->skip_end is where we stopped, and os->ind
+ * is where we are now.
+ */
+static void permute(apr_getopt_t *os)
+{
+    int len1 = os->skip_end - os->skip_start;
+    int len2 = os->ind - os->skip_end;
+
+    if (os->interleave) {
+        /*
+         * Exchange the sequences argv[os->skip_start..os->skip_end-1] and
+         * argv[os->skip_end..os->ind-1].  The easiest way to do that is
+         * to reverse the entire range and then reverse the two
+         * sub-ranges.
+         */
+        reverse(os->argv, os->skip_start, len1 + len2);
+        reverse(os->argv, os->skip_start, len2);
+        reverse(os->argv, os->skip_start + len2, len1);
+    }
+
+    /* Reset skip range to the new location of the non-option sequence. */
+    os->skip_start += len2;
+    os->skip_end += len2;
+}
+
+/* Helper function to print out an error involving a long option */
+static apr_status_t serr(apr_getopt_t *os, const char *err, const char *str,
+                         apr_status_t status)
+{
+    if (os->errfn)
+        (os->errfn)(os->errarg, "%s: %s: %s\n", 
+                    apr_filepath_name_get(*os->argv), err, str);
+    return status;
+}
+
+/* Helper function to print out an error involving a short option */
+static apr_status_t cerr(apr_getopt_t *os, const char *err, int ch,
+                         apr_status_t status)
+{
+    if (os->errfn)
+        (os->errfn)(os->errarg, "%s: %s: %c\n", 
+                    apr_filepath_name_get(*os->argv), err, ch);
+    return status;
+}
+
+APR_DECLARE(apr_status_t) apr_getopt_long(apr_getopt_t *os,
+                                          const apr_getopt_option_t *opts,
+                                          int *optch, const char **optarg)
+{
+    const char *p;
+    int i;
+
+    /* Let the calling program reset option processing. */
+    if (os->reset) {
+        os->place = EMSG;
+        os->ind = 1;
+        os->reset = 0;
+    }
+
+    /*
+     * We can be in one of two states: in the middle of processing a
+     * run of short options, or about to process a new argument.
+     * Since the second case can lead to the first one, handle that
+     * one first.  */
+    p = os->place;
+    if (*p == '\0') {
+        /* If we are interleaving, skip non-option arguments. */
+        if (os->interleave) {
+            while (os->ind < os->argc && *os->argv[os->ind] != '-')
+                os->ind++;
+            os->skip_end = os->ind;
+        }
+        if (os->ind >= os->argc || *os->argv[os->ind] != '-') {
+            os->ind = os->skip_start;
+            return APR_EOF;
+        }
+
+        p = os->argv[os->ind++] + 1;
+        if (*p == '-' && p[1] != '\0') {        /* Long option */
+            /* Search for the long option name in the caller's table. */
+            apr_size_t len = 0;
+
+            p++;
+            for (i = 0; ; i++) {
+                if (opts[i].optch == 0)             /* No match */
+                    return serr(os, "invalid option", p - 2, APR_BADCH);
+
+                if (opts[i].name) {
+                    len = strlen(opts[i].name);
+                    if (strncmp(p, opts[i].name, len) == 0
+                        && (p[len] == '\0' || p[len] == '='))
+                        break;
+                }
+            }
+            *optch = opts[i].optch;
+
+            if (opts[i].has_arg) {
+                if (p[len] == '=')             /* Argument inline */
+                    *optarg = p + len + 1;
+                else { 
+                    if (os->ind >= os->argc)   /* Argument missing */
+                        return serr(os, "missing argument", p - 2, APR_BADARG);
+                    else                       /* Argument in next arg */
+                        *optarg = os->argv[os->ind++];
+                }
+            } else {
+                *optarg = NULL;
+                if (p[len] == '=')
+                    return serr(os, "erroneous argument", p - 2, APR_BADARG);
+            }
+            permute(os);
+            return APR_SUCCESS;
+        } else {
+            if (*p == '-') {                 /* Bare "--"; we're done */
+                permute(os);
+                os->ind = os->skip_start;
+                return APR_EOF;
+            }
+            else 
+                if (*p == '\0')                    /* Bare "-" is illegal */
+                    return serr(os, "invalid option", p, APR_BADCH);
+        }
+    }
+
+    /*
+     * Now we're in a run of short options, and *p is the next one.
+     * Look for it in the caller's table.
+     */
+    for (i = 0; ; i++) {
+        if (opts[i].optch == 0)                     /* No match */
+            return cerr(os, "invalid option character", *p, APR_BADCH);
+
+        if (*p == opts[i].optch)
+            break;
+    }
+    *optch = *p++;
+
+    if (opts[i].has_arg) {
+        if (*p != '\0')                         /* Argument inline */
+            *optarg = p;
+        else { 
+            if (os->ind >= os->argc)           /* Argument missing */
+                return cerr(os, "missing argument", *optch, APR_BADARG);
+            else                               /* Argument in next arg */
+                *optarg = os->argv[os->ind++];
+        }
+        os->place = EMSG;
+    } else {
+        *optarg = NULL;
+        os->place = p;
+    }
+
+    permute(os);
+    return APR_SUCCESS;
+}