[Spice-devel] [PATCH spice 3/3] Copy common/win/my_getopt-1.5/my_getopt client/windows

Marc-André Lureau marcandre.lureau at gmail.com
Thu Mar 22 15:29:13 PDT 2012


---
 client/windows/my_getopt.cpp |  301 +++++++++++++++++++++++++++++++++++++++---
 client/windows/my_getopt.h   |   72 ++++++++++
 2 files changed, 352 insertions(+), 21 deletions(-)
 create mode 100644 client/windows/my_getopt.h

diff --git a/client/windows/my_getopt.cpp b/client/windows/my_getopt.cpp
index 905b717..5237b8e 100644
--- a/client/windows/my_getopt.cpp
+++ b/client/windows/my_getopt.cpp
@@ -1,22 +1,281 @@
 /*
-   Copyright (C) 2009 Red Hat, Inc.
-
-   This 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.
-
-   This 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 this library; if not, see <http://www.gnu.org/licenses/>.
-*/
-#ifdef HAVE_CONFIG_H
-#include <config.h>
-#endif
-
-#include "common.h"
-#include "../../common/win/my_getopt-1.5/my_getopt.c"
+ *  my_getopt.c - my re-implementation of getopt.
+ *  Copyright 1997, 2000, 2001, 2002, 2006, Benjamin Sittler
+ *
+ *  Permission is hereby granted, free of charge, to any person
+ *  obtaining a copy of this software and associated documentation
+ *  files (the "Software"), to deal in the Software without
+ *  restriction, including without limitation the rights to use, copy,
+ *  modify, merge, publish, distribute, sublicense, and/or sell copies
+ *  of the Software, and to permit persons to whom the Software is
+ *  furnished to do so, subject to the following conditions:
+ *
+ *  The above copyright notice and this permission notice shall be
+ *  included in all copies or substantial portions of the Software.
+ *
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ *  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ *  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ *  NONINFRINGEMENT.  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ *  HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ *  WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ *  DEALINGS IN THE SOFTWARE.
+ */
+
+#include <sys/types.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include "my_getopt.h"
+
+int my_optind=1, my_opterr=1, my_optopt=0;
+char *my_optarg=0;
+
+/* reset argument parser to start-up values */
+int my_getopt_reset(void)
+{
+    my_optind = 1;
+    my_opterr = 1;
+    my_optopt = 0;
+    my_optarg = 0;
+    return 0;
+}
+
+/* this is the plain old UNIX getopt, with GNU-style extensions. */
+/* if you're porting some piece of UNIX software, this is all you need. */
+/* this supports GNU-style permution and optional arguments */
+
+int my_getopt(int argc, char * argv[], const char *opts)
+{
+  static int charind=0;
+  char mode, colon_mode;
+  int off = 0, opt = -1;
+
+  if(getenv("POSIXLY_CORRECT")) colon_mode = mode = '+';
+  else {
+    if((colon_mode = *opts) == ':') off ++;
+    if(((mode = opts[off]) == '+') || (mode == '-')) {
+      off++;
+      if((colon_mode != ':') && ((colon_mode = opts[off]) == ':'))
+        off ++;
+    }
+  }
+  my_optarg = 0;
+  if(charind) {
+    const char *s;
+    my_optopt = argv[my_optind][charind];
+    for(s=opts+off; *s; s++) if(my_optopt == *s) {
+      charind++;
+      if((*(++s) == ':') || ((my_optopt == 'W') && (*s == ';'))) {
+        if(argv[my_optind][charind]) {
+          my_optarg = &(argv[my_optind++][charind]);
+          charind = 0;
+        } else if(*(++s) != ':') {
+          charind = 0;
+          if(++my_optind >= argc) {
+            if(my_opterr) fprintf(stderr,
+                                "%s: option requires an argument -- %c\n",
+                                argv[0], my_optopt);
+            opt = (colon_mode == ':') ? ':' : '?';
+            goto my_getopt_ok;
+          }
+          my_optarg = argv[my_optind++];
+        }
+      }
+      opt = my_optopt;
+      goto my_getopt_ok;
+    }
+    if(my_opterr) fprintf(stderr,
+                        "%s: illegal option -- %c\n",
+                        argv[0], my_optopt);
+    opt = '?';
+    if(argv[my_optind][++charind] == '\0') {
+      my_optind++;
+      charind = 0;
+    }
+  my_getopt_ok:
+    if(charind && ! argv[my_optind][charind]) {
+      my_optind++;
+      charind = 0;
+    }
+  } else if((my_optind >= argc) ||
+             ((argv[my_optind][0] == '-') &&
+              (argv[my_optind][1] == '-') &&
+              (argv[my_optind][2] == '\0'))) {
+    my_optind++;
+    opt = -1;
+  } else if((argv[my_optind][0] != '-') ||
+             (argv[my_optind][1] == '\0')) {
+    char *tmp;
+    int i, j, k;
+
+    if(mode == '+') opt = -1;
+    else if(mode == '-') {
+      my_optarg = argv[my_optind++];
+      charind = 0;
+      opt = 1;
+    } else {
+      for(i=j=my_optind; i<argc; i++) if((argv[i][0] == '-') &&
+                                        (argv[i][1] != '\0')) {
+        my_optind=i;
+        opt=my_getopt(argc, argv, opts);
+        while(i > j) {
+          tmp=argv[--i];
+          for(k=i; k+1<my_optind; k++) argv[k]=argv[k+1];
+          argv[--my_optind]=tmp;
+        }
+        break;
+      }
+      if(i == argc) opt = -1;
+    }
+  } else {
+    charind++;
+    opt = my_getopt(argc, argv, opts);
+  }
+  if (my_optind > argc) my_optind = argc;
+  return opt;
+}
+
+/* this is the extended getopt_long{,_only}, with some GNU-like
+ * extensions. Implements _getopt_internal in case any programs
+ * expecting GNU libc getopt call it.
+ */
+
+int _my_getopt_internal(int argc, char * argv[], const char *shortopts,
+                     const struct option *longopts, int *longind,
+                     int long_only)
+{
+  char mode, colon_mode = *shortopts;
+  int shortoff = 0, opt = -1;
+
+  if(getenv("POSIXLY_CORRECT")) colon_mode = mode = '+';
+  else {
+    if((colon_mode = *shortopts) == ':') shortoff ++;
+    if(((mode = shortopts[shortoff]) == '+') || (mode == '-')) {
+      shortoff++;
+      if((colon_mode != ':') && ((colon_mode = shortopts[shortoff]) == ':'))
+        shortoff ++;
+    }
+  }
+  my_optarg = 0;
+  if((my_optind >= argc) ||
+      ((argv[my_optind][0] == '-') &&
+       (argv[my_optind][1] == '-') &&
+       (argv[my_optind][2] == '\0'))) {
+    my_optind++;
+    opt = -1;
+  } else if((argv[my_optind][0] != '-') ||
+            (argv[my_optind][1] == '\0')) {
+    char *tmp;
+    int i, j, k;
+
+    opt = -1;
+    if(mode == '+') return -1;
+    else if(mode == '-') {
+      my_optarg = argv[my_optind++];
+      return 1;
+    }
+    for(i=j=my_optind; i<argc; i++) if((argv[i][0] == '-') &&
+                                    (argv[i][1] != '\0')) {
+      my_optind=i;
+      opt=_my_getopt_internal(argc, argv, shortopts,
+                              longopts, longind,
+                              long_only);
+      while(i > j) {
+        tmp=argv[--i];
+        for(k=i; k+1<my_optind; k++)
+          argv[k]=argv[k+1];
+        argv[--my_optind]=tmp;
+      }
+      break;
+    }
+  } else if((!long_only) && (argv[my_optind][1] != '-'))
+    opt = my_getopt(argc, argv, shortopts);
+  else {
+    int charind, offset;
+    int found = 0, ind, hits = 0;
+
+    if(((my_optopt = argv[my_optind][1]) != '-') && ! argv[my_optind][2]) {
+      int c;
+
+      ind = shortoff;
+      while((c = shortopts[ind++])) {
+        if(((shortopts[ind] == ':') ||
+            ((c == 'W') && (shortopts[ind] == ';'))) &&
+           (shortopts[++ind] == ':'))
+          ind ++;
+        if(my_optopt == c) return my_getopt(argc, argv, shortopts);
+      }
+    }
+    offset = 2 - (argv[my_optind][1] != '-');
+    for(charind = offset;
+        (argv[my_optind][charind] != '\0') &&
+          (argv[my_optind][charind] != '=');
+        charind++);
+    for(ind = 0; longopts[ind].name && !hits; ind++)
+      if((strlen(longopts[ind].name) == (size_t) (charind - offset)) &&
+         (strncmp(longopts[ind].name,
+                  argv[my_optind] + offset, charind - offset) == 0))
+        found = ind, hits++;
+    if(!hits) for(ind = 0; longopts[ind].name; ind++)
+      if(strncmp(longopts[ind].name,
+                 argv[my_optind] + offset, charind - offset) == 0)
+        found = ind, hits++;
+    if(hits == 1) {
+      opt = 0;
+
+      if(argv[my_optind][charind] == '=') {
+        if(longopts[found].has_arg == 0) {
+          opt = '?';
+          if(my_opterr) fprintf(stderr,
+                             "%s: option `--%s' doesn't allow an argument\n",
+                             argv[0], longopts[found].name);
+        } else {
+          my_optarg = argv[my_optind] + ++charind;
+          charind = 0;
+        }
+      } else if(longopts[found].has_arg == 1) {
+        if(++my_optind >= argc) {
+          opt = (colon_mode == ':') ? ':' : '?';
+          if(my_opterr) fprintf(stderr,
+                             "%s: option `--%s' requires an argument\n",
+                             argv[0], longopts[found].name);
+        } else my_optarg = argv[my_optind];
+      }
+      if(!opt) {
+        if (longind) *longind = found;
+        if(!longopts[found].flag) opt = longopts[found].val;
+        else *(longopts[found].flag) = longopts[found].val;
+      }
+      my_optind++;
+    } else if(!hits) {
+      if(offset == 1) opt = my_getopt(argc, argv, shortopts);
+      else {
+        opt = '?';
+        if(my_opterr) fprintf(stderr,
+                           "%s: unrecognized option `%s'\n",
+                           argv[0], argv[my_optind++]);
+      }
+    } else {
+      opt = '?';
+      if(my_opterr) fprintf(stderr,
+                         "%s: option `%s' is ambiguous\n",
+                         argv[0], argv[my_optind++]);
+    }
+  }
+  if (my_optind > argc) my_optind = argc;
+  return opt;
+}
+
+int my_getopt_long(int argc, char * argv[], const char *shortopts,
+                const struct option *longopts, int *longind)
+{
+  return _my_getopt_internal(argc, argv, shortopts, longopts, longind, 0);
+}
+
+int my_getopt_long_only(int argc, char * argv[], const char *shortopts,
+                const struct option *longopts, int *longind)
+{
+  return _my_getopt_internal(argc, argv, shortopts, longopts, longind, 1);
+}
diff --git a/client/windows/my_getopt.h b/client/windows/my_getopt.h
new file mode 100644
index 0000000..c75101a
--- /dev/null
+++ b/client/windows/my_getopt.h
@@ -0,0 +1,72 @@
+/*
+ *  my_getopt.h - interface to my re-implementation of getopt.
+ *  Copyright 1997, 2000, 2001, 2002, 2006, Benjamin Sittler
+ *
+ *  Permission is hereby granted, free of charge, to any person
+ *  obtaining a copy of this software and associated documentation
+ *  files (the "Software"), to deal in the Software without
+ *  restriction, including without limitation the rights to use, copy,
+ *  modify, merge, publish, distribute, sublicense, and/or sell copies
+ *  of the Software, and to permit persons to whom the Software is
+ *  furnished to do so, subject to the following conditions:
+ *
+ *  The above copyright notice and this permission notice shall be
+ *  included in all copies or substantial portions of the Software.
+ *
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ *  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ *  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ *  NONINFRINGEMENT.  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ *  HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ *  WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ *  DEALINGS IN THE SOFTWARE.
+ */
+
+#ifndef MY_GETOPT_H_INCLUDED
+#define MY_GETOPT_H_INCLUDED
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* reset argument parser to start-up values */
+extern int my_getopt_reset(void);
+
+/* UNIX-style short-argument parser */
+extern int my_getopt(int argc, char * argv[], const char *opts);
+
+extern int my_optind, my_opterr, my_optopt;
+extern char *my_optarg;
+
+struct option {
+  const char *name;
+  int has_arg;
+  int *flag;
+  int val;
+};
+
+/* human-readable values for has_arg */
+#undef no_argument
+#define no_argument 0
+#undef required_argument
+#define required_argument 1
+#undef optional_argument
+#define optional_argument 2
+
+/* GNU-style long-argument parsers */
+extern int my_getopt_long(int argc, char * argv[], const char *shortopts,
+                       const struct option *longopts, int *longind);
+
+extern int my_getopt_long_only(int argc, char * argv[], const char *shortopts,
+                            const struct option *longopts, int *longind);
+
+extern int _my_getopt_internal(int argc, char * argv[], const char *shortopts,
+                            const struct option *longopts, int *longind,
+                            int long_only);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* MY_GETOPT_H_INCLUDED */
-- 
1.7.7.6



More information about the Spice-devel mailing list