From 27f9f0c9d82366b4b27e2417e2b0cbd35a9f907e Mon Sep 17 00:00:00 2001
From: Dieter Baron <dillo@nih.at>
Date: Thu, 18 Jan 2024 13:33:50 +0100
Subject: [PATCH] Revert "No longer depend on getopt_long()."

This reverts commit c1b9200bb923a0e55ed1062ec7bada232b8cad8b.
---
 CMakeLists.txt       |   2 +
 cmake-config.h.in    |   2 +
 regress/dbrestore.cc | 102 ++++++----
 src/CMakeLists.txt   |   3 +
 src/Commandline.cc   | 182 ++++++++---------
 src/Commandline.h    |   4 -
 src/compat.h         |  11 ++
 src/getopt_long.cc   | 451 +++++++++++++++++++++++++++++++++++++++++++
 src/getopt_long.h    |  65 +++++++
 src/getprogname.cc   |  54 ++++++
 10 files changed, 738 insertions(+), 138 deletions(-)
 create mode 100644 src/getopt_long.cc
 create mode 100644 src/getopt_long.h
 create mode 100644 src/getprogname.cc

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 442276f9..b3eb2347 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -63,6 +63,8 @@ add_dependencies(distcheck dist)
 check_function_exists(MD5Init HAVE_MD5INIT)
 check_function_exists(SHA1Init HAVE_SHA1INIT)
 check_function_exists(fnmatch HAVE_FNMATCH)
+check_function_exists(getopt_long HAVE_GETOPT_LONG)
+check_function_exists(getprogname HAVE_GETPROGNAME)
 check_symbol_exists(_stricmp string.h HAVE__STRICMP)
 check_symbol_exists(strcasecmp strings.h HAVE_STRCASECMP)
 
diff --git a/cmake-config.h.in b/cmake-config.h.in
index d6ab572b..091c9b24 100644
--- a/cmake-config.h.in
+++ b/cmake-config.h.in
@@ -9,6 +9,8 @@
 #cmakedefine HAVE_TOMLPLUSPLUS
 
 #cmakedefine HAVE_FNMATCH
+#cmakedefine HAVE_GETOPT_LONG
+#cmakedefine HAVE_GETPROGNAME
 #cmakedefine HAVE_MD5INIT
 #cmakedefine HAVE_SHA1INIT
 #cmakedefine HAVE_STRCASECMP
diff --git a/regress/dbrestore.cc b/regress/dbrestore.cc
index 19c281a9..cd2a5892 100644
--- a/regress/dbrestore.cc
+++ b/regress/dbrestore.cc
@@ -66,61 +66,95 @@ static int restore_table(sqlite3 *db, FILE *f);
 static void unget_line(const std::string &line);
 static std::vector<std::string> split(const std::string &string, const std::string &separaptor, bool strip_whitespace = false);
 
-std::vector<Commandline::Option> dbrestore_options = {
-    Commandline::Option("db-version", "version", "specify DB schema version"),
-    Commandline::Option("sql","file", "take SQL schema from FILE"),
-    Commandline::Option("type", 't', "type", "specify type of database: mamedb (default) or ckmamedb)")
+
+#define QUERY_COLS_FMT "pragma table_info(%s)"
+
+const char *usage = "usage: %s [-hV] [--db-version VERSION] [--sql SQL_INIT_FILE] [-t db-type] dump-file db-file\n";
+
+char help_head[] = PACKAGE " by Dieter Baron and Thomas Klausner\n\n";
+
+char help[] = "\n"
+              "  --db-version VERSION    specify version of database schema\n"
+	      "  -h, --help              display this help message\n"
+              "  --sql SQL_INIT_FILE     use table definitions from this SQL init file\n"
+	      "  -t, --type TYPE         restore database of type TYPE (ckmamedb, mamedb, memdb)\n"
+	      "  -V, --version           display version number\n"
+	      "\nReport bugs to " PACKAGE_BUGREPORT ".\n";
+
+char version_string[] = PACKAGE " " VERSION "\n"
+				"Copyright (C) 2014-2021 Dieter Baron and Thomas Klausner\n" PACKAGE " comes with ABSOLUTELY NO WARRANTY, to the extent permitted by law.\n";
+
+
+#define OPTIONS "ht:V"
+
+enum {
+    OPT_DB_VERSION = 256,
+    OPT_SQL
+};
+
+struct option options[] = {
+    {"db-version", 1, 0, OPT_DB_VERSION },
+    {"help", 0, 0, 'h'},
+    {"sql", 1, 0, OPT_SQL },
+    {"type", 1, 0, 't'},
+    {"version", 0, 0, 'V'}
 };
 
-#define PROGRAM_NAME "dbrestore"
 
 int main(int argc, char *argv[]) {
+    setprogname(argv[0]);
+
     DBType type = DBTYPE_ROMDB;
     std::string sql_file;
     int db_version = -1;
 
-    const char *header = PROGRAM_NAME " by Dieter Baron and Thomas Klausner";
-    const char *footer = "Report bugs to " PACKAGE_BUGREPORT ".";
-    const char *version = "dumpgame (" PACKAGE " " VERSION ")\nCopyright (C) 2021-2024 Dieter Baron and Thomas Klausner\n"
-        PACKAGE " " VERSION "\n"
-        PACKAGE " comes with ABSOLUTELY NO WARRANTY, to the extent permitted by law.\n";
-
-    auto commandline = Commandline(dbrestore_options, "dump-file db-file", header, footer, version);
-
-    auto arguments = commandline.parse(argc, argv);
-
-    for (const auto& option: arguments.options) {
-        if (option.name == "db-version") {
+    opterr = 0;
+    int c;
+    while ((c = getopt_long(argc, argv, OPTIONS, options, 0)) != EOF) {
+	switch (c) {
+	case 'h':
+	    fputs(help_head, stdout);
+	    printf(usage, getprogname());
+	    fputs(help, stdout);
+	    exit(0);
+	case 'V':
+	    fputs(version_string, stdout);
+	    exit(0);
+
+	case 't':
+	    if ((type = db_type(optarg)) == DBTYPE_INVALID) {
+		fprintf(stderr, "%s: unknown db type '%s'\n", getprogname(), optarg);
+		exit(1);
+	    }
+	    break;
+            
+        case OPT_DB_VERSION:
             try {
                 size_t idx;
-                db_version = std::stoi(option.argument, &idx);
-                if (option.argument[idx] != '\0') {
+                db_version = std::stoi(optarg, &idx);
+                if (optarg[idx] != '\0') {
                     throw std::invalid_argument("");
                 }
             }
             catch (...) {
-                fprintf(stderr, "%s: invalid DB schema version '%s'\n", getprogname(), option.argument.c_str());
+                fprintf(stderr, "%s: invalid DB schema version '%s'\n", getprogname(), optarg);
                 exit(1);
             }
-        }
-        else if (option.name == "sql") {
-            sql_file = option.argument;
-        }
-        else if (option.name == "type") {
-            if ((type = db_type(option.argument)) == DBTYPE_INVALID) {
-                fprintf(stderr, "%s: unknown db type '%s'\n", getprogname(), option.argument.c_str());
-                exit(1);
-            }
-        }
+            break;
+            
+        case OPT_SQL:
+            sql_file = optarg;
+            break;
+	}
     }
 
-    if (arguments.arguments.size() != 2) {
-        commandline.usage(false, stderr);
+    if (optind != argc - 2) {
+	fprintf(stderr, usage, getprogname());
 	exit(1);
     }
 
-    std::string dump_fname = arguments.arguments[0];
-    std::string db_fname = arguments.arguments[1];
+    std::string dump_fname = argv[optind];
+    std::string db_fname = argv[optind + 1];
 
     output.set_error_file(dump_fname);
 
diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index ebfc8edd..c1f1bf3e 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -1,3 +1,6 @@
+if(NOT HAVE_GETPROGRAME)
+  list(APPEND COMPATIBILITY getprogname.cc)
+endif()
 if(NOT HAVE_MD5INIT)
   list(APPEND COMPATIBILITY md5.cc)
 endif()
diff --git a/src/Commandline.cc b/src/Commandline.cc
index ab7ab0d9..3f36aff3 100644
--- a/src/Commandline.cc
+++ b/src/Commandline.cc
@@ -1,5 +1,5 @@
 /*
-  Commandline.cc -- parse command line options and arguments
+  Commandline.h -- parse command line options and arguments
   Copyright (C) 2021 Dieter Baron and Thomas Klausner
 
   This file is part of ckmame, a program to check rom sets for MAME.
@@ -36,119 +36,101 @@
 #include <algorithm>
 #include <cctype>
 #include <sstream>
-#include <iostream>
 #include <unordered_map>
 #include <utility>
 
+#include "compat.h"
+
+#include "Exception.h"
+
+extern int optind;
+
 Commandline::Commandline(std::vector<Option> options_, std::string arguments_, std::string header_, std::string footer_, std::string version_) : options(std::move(options_)), arguments(std::move(arguments_)), header(std::move(header_)), footer(std::move(footer_)), version(std::move(version_)), options_sorted(false) {
     add_option(Option("help", 'h', "display this help message"));
-    add_option(Option("version", 'V', "display version integer"));
+    add_option(Option("version", 'V', "display version number"));
 }
 
 
 ParsedCommandline Commandline::parse(int argc, char *const *argv) {
-    program_name = argv[0];
-
-    std::unordered_map<char, const Option*> short_options;
-    std::unordered_map<std::string, const Option*> long_options;
-
-    for (const auto& option: options) {
-        if (option.short_name) {
-            short_options[*option.short_name] = &option;
+    std::string short_options;
+    std::vector<struct option> long_options;
+    std::unordered_map<int, size_t> option_indices;
+    int next_index = 256;
+    
+    for (const auto &option : options) {
+//#define DEBUG_OPTIONS
+#ifdef DEBUG_OPTIONS
+        printf("option '%s'", option.name.c_str());
+        if (option.short_name.has_value()) {
+            printf("/'%c'", option.short_name.value());
+        }
+        if (option.has_argument()) {
+            printf(", argument '%s'", option.argument_name.c_str());
         }
-        long_options[option.name] = &option;
+        printf(", description '%s'\n", option.description.c_str());
+#endif
+        int index;
+        if (option.short_name.has_value()) {
+            index = option.short_name.value();
+            short_options += option.short_name.value();
+            if (option.has_argument()) {
+                short_options += ":";
+            }
+        }
+        else {
+            index = next_index++;
+        }
+        
+        option_indices[index] = long_options.size();
+        struct option long_option = {
+            option.name.c_str(), option.has_argument() ? 1 : 0, nullptr, index
+        };
+        long_options.push_back(long_option);
     }
-
+    
+#ifdef DEBUG_OPTIONS
+    printf("short options: '%s'\n", short_options.c_str());
+#endif
+    struct option terminator = { nullptr, 0, nullptr, 0 };
+    long_options.push_back(terminator);
+        
     auto parsed_commandline = ParsedCommandline();
-
-    auto in_options = true;
-
-    for (int index = 1; index < argc; index += 1) {
-        auto argument = std::string(argv[index]);
-
-        if (in_options) {
-            if (argument.size() >=2 && argument[0] == '-' && argument[1] == '-' /* argument.starts_with("--") */) {
-                auto equals = argument.find('=');
-                auto option_name = argument.substr(2, equals == std::string::npos ? equals : equals - 2);
-                auto it = long_options.find(option_name);
-                if (it == long_options.end()) {
-                    usage(false, stderr);
-                    std::cerr << "unknown option '--" << option_name << "'\n";
-                    exit(1);
-                }
-                auto option_argument = std::string{};
-                if (equals != std::string::npos) {
-                    if (it->second->has_argument()) {
-                        parsed_commandline.add_option(option_name, argument.substr(equals + 1));
-                    }
-                    else {
-                        usage(false, stderr);
-                        std::cerr << "option '--" << option_name << "' doesn't take an argument\n";
-                        exit(1);
-                    }
-                }
-                else {
-                    if (it->second->has_argument()) {
-                        if (index == argc - 1) {
-                            usage(false, stderr);
-                            std::cerr << "missing argument for option '--" << option_name << "'\n";
-                            exit(1);
-                        }
-                        index += 1;
-                        parsed_commandline.add_option(option_name, argv[index]);
-                    }
-                    else {
-                        parsed_commandline.add_option(option_name, "");
-                    }
-                }
-            }
-            else if (argument.size() >= 1 && argument[0] == '-' /* argument.starts_with('-') */) {
-                for (size_t position = 1; position < argument.size(); position += 1) {
-                    auto option_name = argument[position];
-                    auto it = short_options.find(option_name);
-                    if (it == short_options.end()) {
-                        usage(false, stderr);
-                        std::cerr << "unknown option '-" << option_name << "'\n";
-                        exit(1);
-                    }
-                    if (it->second->has_argument()) {
-                        position += 1;
-                        if (position < argument.size()) {
-                            parsed_commandline.add_option(it->second->name, argument.substr(position));
-                        }
-                        else {
-                            if (index == argc - 1) {
-                                usage(false, stderr);
-                                std::cerr << "missing argument for option '-" << option_name << "'\n";
-                                exit(1);
-                            }
-                            index += 1;
-                            parsed_commandline.add_option(it->second->name, argv[index]);
-                        }
-                        break;
-                    }
-                    else {
-                        parsed_commandline.add_option(it->second->name, "");
-                    }
-                }
-            }
-            else {
-                in_options = false;
-            }
+    opterr = 0;
+    int c;
+    while ((c = getopt_long(argc, argv, short_options.c_str(), long_options.data(), nullptr)) != EOF) {
+        if (c == '?') {
+	    usage(false, stderr);
+	    fprintf(stderr, "unknown option\n"); // TODO: include unknown option, how to get that information?
+	    exit(1);
         }
-
-        if (!in_options) {
-            parsed_commandline.arguments.emplace_back(argument);
+        if (c == ':') {
+	    usage(false, stderr);
+	    fprintf(stderr, "option missing argument\n"); // TODO: include unknown option, how to get that information?
+	    exit(1);
+        }
+        
+        auto it = option_indices.find(c);
+        if (it == option_indices.end()) {
+	    usage(false, stderr);
+	    fprintf(stderr, "unknown option '%c'\n", c);
+	    exit(1);
         }
+        const auto &option = long_options[it->second];
+        
+        parsed_commandline.options.emplace_back(option.name, option.has_arg ? optarg : "");
+    }
+    
+    for (auto i = optind; i < argc; i++) {
+        parsed_commandline.arguments.emplace_back(argv[i]);
     }
 
     if (parsed_commandline.find_first("help").has_value()) {
-        usage(true);
-        exit(0);
+	usage(true);
+	exit(0);
     }
     if (parsed_commandline.find_first("version").has_value()) {
-        std::cout << version << std::endl;
-        exit(0);
+	fputs(version.c_str(), stdout);
+	exit(0);
     }
 
     return parsed_commandline;
@@ -168,7 +150,7 @@ std::optional<std::string> ParsedCommandline::find_first(const std::string &name
 [[maybe_unused]] std::optional<std::string> ParsedCommandline::find_last(const std::string &name) const {
     for (auto it = options.rbegin(); it != options.rend(); it++) {
         const auto &option = *it;
-
+        
         if (option.name == name) {
             return option.argument;
         }
@@ -199,7 +181,7 @@ void Commandline::usage(bool full, FILE *fout) {
         fprintf(fout, "%s\n\n", header.c_str());
     }
 
-    fprintf(fout, "Usage: %s", program_name.c_str());
+    fprintf(fout, "Usage: %s", getprogname());
     if (!short_options_without_argument.str().empty()) {
         fprintf(fout, " [-%s]", short_options_without_argument.str().c_str());
     }
@@ -256,8 +238,8 @@ void Commandline::add_option(Commandline::Option option) {
 
 void Commandline::sort_options() {
     if (!options_sorted) {
-    std::sort(options.begin(), options.end());
-    options_sorted = true;
+	std::sort(options.begin(), options.end());
+	options_sorted = true;
     }
 }
 
@@ -288,7 +270,7 @@ bool Commandline::Option::operator<(const Option &other) const {
             return compare_char(name[0], other.short_name.value()) < 0;
         }
         else {
-            return std::lexicographical_compare(name.begin(), name.end(), other.name.begin(), other.name.end());
+            return strcasecmp(name.c_str(), other.name.c_str()) < 0;
         }
     }
 }
diff --git a/src/Commandline.h b/src/Commandline.h
index bc2b88bf..97547809 100644
--- a/src/Commandline.h
+++ b/src/Commandline.h
@@ -53,9 +53,6 @@ class ParsedCommandline {
     [[nodiscard]] std::optional<std::string> find_first(const std::string &name) const;
     [[maybe_unused]] [[nodiscard]] std::optional<std::string> find_last(const std::string &name) const;
 
-    void add_argument(std::string name) {arguments.emplace_back(std::move(name));}
-    void add_option(std::string name, std::string argument) {options.emplace_back(std::move(name), std::move(argument));}
-
     std::vector<OptionValue> options;
     std::vector<std::string> arguments;
 };
@@ -85,7 +82,6 @@ class Commandline {
     void add_option(Option option);
 
     std::vector<Option> options;
-    std::string program_name;
     std::string arguments;
     std::string header;
     std::string footer;
diff --git a/src/compat.h b/src/compat.h
index 0f3395af..984fd7ae 100644
--- a/src/compat.h
+++ b/src/compat.h
@@ -43,6 +43,17 @@
 #include "compat_fnmatch.h"
 #endif
 
+#ifdef HAVE_GETOPT_LONG
+#include <getopt.h>
+#else
+#include "getopt_long.h"
+#endif
+
+#ifndef HAVE_GETPROGNAME
+const char *getprogname(void);
+void setprogname(const char *);
+#endif
+
 #if defined(HAVE_STRCASECMP)
 #include <strings.h>
 #else
diff --git a/src/getopt_long.cc b/src/getopt_long.cc
new file mode 100644
index 00000000..956fb47a
--- /dev/null
+++ b/src/getopt_long.cc
@@ -0,0 +1,451 @@
+/*	$NetBSD: getopt_long.c,v 1.15 2002/01/31 22:43:40 tv Exp $	*/
+
+/*-
+ * Copyright (c) 2000 The NetBSD Foundation, Inc.
+ * All rights reserved.
+ *
+ * This code is derived from software contributed to The NetBSD Foundation
+ * by Dieter Baron and Thomas Klausner.
+ *
+ * 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 NetBSD
+ *        Foundation, Inc. and its contributors.
+ * 4. Neither the name of The NetBSD Foundation 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 NETBSD FOUNDATION, INC. 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 FOUNDATION 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 <errno.h>
+#include <stdarg.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "getopt_long.h"
+
+static void mywarnx(const char *fmt, ...);
+#define warnx mywarnx
+
+int opterr = 1;   /* if error message should be printed */
+int optind = 1;   /* index into parent argv vector */
+int optopt = '?'; /* character checked for validity */
+int optreset;     /* reset getopt */
+char *optarg;     /* argument associated with option */
+
+#if !HAVE_GETOPT_LONG
+#define IGNORE_FIRST (*options == '-' || *options == '+')
+#define PRINT_ERROR ((opterr) && ((*options != ':') || (IGNORE_FIRST && options[1] != ':')))
+#define IS_POSIXLY_CORRECT (getenv("POSIXLY_CORRECT") != NULL)
+#define PERMUTE (!IS_POSIXLY_CORRECT && !IGNORE_FIRST)
+/* TODO: GNU ignores PC if *options == '-' */
+#define IN_ORDER (!IS_POSIXLY_CORRECT && *options == '-')
+
+/* return values */
+#define BADCH (int)'?'
+#define BADARG ((IGNORE_FIRST && options[1] == ':') || (*options == ':') ? (int)':' : (int)'?')
+#define INORDER (int)1
+
+#define EMSG ""
+
+static int getopt_internal(int, char *const *, const char *);
+static int gcd(int, int);
+static void permute_args(int, int, int, char *const *);
+
+static char *place = EMSG; /* option letter processing */
+
+/* TODO: set optreset to 1 rather than these two */
+static int nonopt_start = -1; /* first non option argument (for permute) */
+static int nonopt_end = -1;   /* first option after non options (for permute) */
+
+/* Error messages */
+static const char recargchar[] = "option requires an argument -- %c";
+static const char recargstring[] = "option requires an argument -- %s";
+static const char ambig[] = "ambiguous option -- %.*s";
+static const char noarg[] = "option doesn't take an argument -- %.*s";
+static const char illoptchar[] = "unknown option -- %c";
+static const char illoptstring[] = "unknown option -- %s";
+
+
+/*
+ * Compute the greatest common divisor of a and b.
+ */
+static int gcd(a, b) int a;
+int b;
+{
+    int c;
+
+    c = a % b;
+    while (c != 0) {
+	a = b;
+	b = c;
+	c = a % b;
+    }
+
+    return b;
+}
+
+/*
+ * Exchange the block from nonopt_start to nonopt_end with the block
+ * from nonopt_end to opt_end (keeping the same order of arguments
+ * in each block).
+ */
+static void permute_args(panonopt_start, panonopt_end, opt_end, nargv) int panonopt_start;
+int panonopt_end;
+int opt_end;
+char *const *nargv;
+{
+    int cstart, cyclelen, i, j, ncycle, nnonopts, nopts, pos;
+    char *swap;
+
+    /*
+     * compute lengths of blocks and number and size of cycles
+     */
+    nnonopts = panonopt_end - panonopt_start;
+    nopts = opt_end - panonopt_end;
+    ncycle = gcd(nnonopts, nopts);
+    cyclelen = (opt_end - panonopt_start) / ncycle;
+
+    for (i = 0; i < ncycle; i++) {
+	cstart = panonopt_end + i;
+	pos = cstart;
+	for (j = 0; j < cyclelen; j++) {
+	    if (pos >= panonopt_end)
+		pos -= nnonopts;
+	    else
+		pos += nopts;
+	    swap = nargv[pos];
+	    /* LINTED const cast */
+	    ((char **)nargv)[pos] = nargv[cstart];
+	    /* LINTED const cast */
+	    ((char **)nargv)[cstart] = swap;
+	}
+    }
+}
+
+/*
+ * getopt_internal --
+ *	Parse argc/argv argument vector.  Called by user level routines.
+ *  Returns -2 if -- is found (can be long option or end of options marker).
+ */
+static int getopt_internal(nargc, nargv, options) int nargc;
+char *const *nargv;
+const char *options;
+{
+    char *oli; /* option letter list index */
+    int optchar;
+
+    optarg = NULL;
+
+    /*
+     * TODO Some programs (like rsyncd) expect to be able to
+     * TODO re-initialize optind to 0 and have getopt_long(3)
+     * TODO properly function again.  Work around this braindamage.
+     */
+    if (optind == 0)
+	optind = 1;
+
+    if (optreset)
+	nonopt_start = nonopt_end = -1;
+start:
+    if (optreset || !*place) { /* update scanning pointer */
+	optreset = 0;
+	if (optind >= nargc) { /* end of argument vector */
+	    place = EMSG;
+	    if (nonopt_end != -1) {
+		/* do permutation, if we have to */
+		permute_args(nonopt_start, nonopt_end, optind, nargv);
+		optind -= nonopt_end - nonopt_start;
+	    }
+	    else if (nonopt_start != -1) {
+		/*
+		 * If we skipped non-options, set optind
+		 * to the first of them.
+		 */
+		optind = nonopt_start;
+	    }
+	    nonopt_start = nonopt_end = -1;
+	    return -1;
+	}
+	if ((*(place = nargv[optind]) != '-') || (place[1] == '\0')) { /* found non-option */
+	    place = EMSG;
+	    if (IN_ORDER) {
+		/*
+		 * GNU extension:
+		 * return non-option as argument to option 1
+		 */
+		optarg = nargv[optind++];
+		return INORDER;
+	    }
+	    if (!PERMUTE) {
+		/*
+		 * if no permutation wanted, stop parsing
+		 * at first non-option
+		 */
+		return -1;
+	    }
+	    /* do permutation */
+	    if (nonopt_start == -1)
+		nonopt_start = optind;
+	    else if (nonopt_end != -1) {
+		permute_args(nonopt_start, nonopt_end, optind, nargv);
+		nonopt_start = optind - (nonopt_end - nonopt_start);
+		nonopt_end = -1;
+	    }
+	    optind++;
+	    /* process next argument */
+	    goto start;
+	}
+	if (nonopt_start != -1 && nonopt_end == -1)
+	    nonopt_end = optind;
+	if (place[1] && *++place == '-') { /* found "--" */
+	    place++;
+	    return -2;
+	}
+    }
+    if ((optchar = (int)*place++) == (int)':' || (oli = strchr(options + (IGNORE_FIRST ? 1 : 0), optchar)) == NULL) {
+	/* option letter unknown or ':' */
+	if (!*place)
+	    ++optind;
+	if (PRINT_ERROR)
+	    warnx(illoptchar, optchar);
+	optopt = optchar;
+	return BADCH;
+    }
+    if (optchar == 'W' && oli[1] == ';') { /* -W long-option */
+	/* TODO: what if no long options provided (called by getopt)? */
+	if (*place)
+	    return -2;
+
+	if (++optind >= nargc) { /* no arg */
+	    place = EMSG;
+	    if (PRINT_ERROR)
+		warnx(recargchar, optchar);
+	    optopt = optchar;
+	    return BADARG;
+	}
+	else /* white space */
+	    place = nargv[optind];
+	/*
+	 * Handle -W arg the same as --arg (which causes getopt to
+	 * stop parsing).
+	 */
+	return -2;
+    }
+    if (*++oli != ':') { /* doesn't take argument */
+	if (!*place)
+	    ++optind;
+    }
+    else { /* takes (optional) argument */
+	optarg = NULL;
+	if (*place) /* no white space */
+	    optarg = place;
+	/* TODO: disable test for :: if PC? (GNU doesn't) */
+	else if (oli[1] != ':') {    /* arg not optional */
+	    if (++optind >= nargc) { /* no arg */
+		place = EMSG;
+		if (PRINT_ERROR)
+		    warnx(recargchar, optchar);
+		optopt = optchar;
+		return BADARG;
+	    }
+	    else
+		optarg = nargv[optind];
+	}
+	place = EMSG;
+	++optind;
+    }
+    /* dump back option letter */
+    return optchar;
+}
+
+#ifdef REPLACE_GETOPT
+/*
+ * getopt --
+ *	Parse argc/argv argument vector.
+ *
+ * [eventually this will replace the real getopt]
+ */
+int getopt(nargc, nargv, options) int nargc;
+char *const *nargv;
+const char *options;
+{
+    int retval;
+
+    if ((retval = getopt_internal(nargc, nargv, options)) == -2) {
+	++optind;
+	/*
+	 * We found an option (--), so if we skipped non-options,
+	 * we have to permute.
+	 */
+	if (nonopt_end != -1) {
+	    permute_args(nonopt_start, nonopt_end, optind, nargv);
+	    optind -= nonopt_end - nonopt_start;
+	}
+	nonopt_start = nonopt_end = -1;
+	retval = -1;
+    }
+    return retval;
+}
+#endif
+
+/*
+ * getopt_long --
+ *	Parse argc/argv argument vector.
+ */
+int getopt_long(nargc, nargv, options, long_options, idx) int nargc;
+char *const *nargv;
+const char *options;
+const struct option *long_options;
+int *idx;
+{
+    int retval;
+
+    /* idx may be NULL */
+
+    if ((retval = getopt_internal(nargc, nargv, options)) == -2) {
+	char *current_argv, *has_equal;
+	size_t current_argv_len;
+	int i, match;
+
+	current_argv = place;
+	match = -1;
+
+	optind++;
+	place = EMSG;
+
+	if (*current_argv == '\0') { /* found "--" */
+	    /*
+	     * We found an option (--), so if we skipped
+	     * non-options, we have to permute.
+	     */
+	    if (nonopt_end != -1) {
+		permute_args(nonopt_start, nonopt_end, optind, nargv);
+		optind -= nonopt_end - nonopt_start;
+	    }
+	    nonopt_start = nonopt_end = -1;
+	    return -1;
+	}
+	if ((has_equal = strchr(current_argv, '=')) != NULL) {
+	    /* argument found (--option=arg) */
+	    current_argv_len = has_equal - current_argv;
+	    has_equal++;
+	}
+	else
+	    current_argv_len = strlen(current_argv);
+
+	for (i = 0; long_options[i].name; i++) {
+	    /* find matching long option */
+	    if (strncmp(current_argv, long_options[i].name, current_argv_len))
+		continue;
+
+	    if (strlen(long_options[i].name) == (unsigned)current_argv_len) {
+		/* exact match */
+		match = i;
+		break;
+	    }
+	    if (match == -1) /* partial match */
+		match = i;
+	    else {
+		/* ambiguous abbreviation */
+		if (PRINT_ERROR)
+		    warnx(ambig, (int)current_argv_len, current_argv);
+		optopt = 0;
+		return BADCH;
+	    }
+	}
+	if (match != -1) { /* option found */
+	    if (long_options[match].has_arg == no_argument && has_equal) {
+		if (PRINT_ERROR)
+		    warnx(noarg, (int)current_argv_len, current_argv);
+		/*
+		 * TODO: GNU sets optopt to val regardless of
+		 * flag
+		 */
+		if (long_options[match].flag == NULL)
+		    optopt = long_options[match].val;
+		else
+		    optopt = 0;
+		return BADARG;
+	    }
+	    if (long_options[match].has_arg == required_argument || long_options[match].has_arg == optional_argument) {
+		if (has_equal)
+		    optarg = has_equal;
+		else if (long_options[match].has_arg == required_argument) {
+		    /*
+		     * optional argument doesn't use
+		     * next nargv
+		     */
+		    optarg = nargv[optind++];
+		}
+	    }
+	    if ((long_options[match].has_arg == required_argument) && (optarg == NULL)) {
+		/*
+		 * Missing argument; leading ':'
+		 * indicates no error should be generated
+		 */
+		if (PRINT_ERROR)
+		    warnx(recargstring, current_argv);
+		/*
+		 * TODO: GNU sets optopt to val regardless
+		 * of flag
+		 */
+		if (long_options[match].flag == NULL)
+		    optopt = long_options[match].val;
+		else
+		    optopt = 0;
+		--optind;
+		return BADARG;
+	    }
+	}
+	else { /* unknown option */
+	    if (PRINT_ERROR)
+		warnx(illoptstring, current_argv);
+	    optopt = 0;
+	    return BADCH;
+	}
+	if (long_options[match].flag) {
+	    *long_options[match].flag = long_options[match].val;
+	    retval = 0;
+	}
+	else
+	    retval = long_options[match].val;
+	if (idx)
+	    *idx = match;
+    }
+    return retval;
+}
+
+extern const char *prg;
+static void
+mywarnx(const char *fmt, ...) {
+    va_list ap;
+
+    fprintf(stderr, "%s", prg);
+    va_start(ap, fmt);
+    vfprintf(stderr, fmt, ap);
+    va_end(ap);
+    fprintf(stderr, "\n");
+    va_start(ap, fmt);
+}
+#endif /* !GETOPT_LONG */
diff --git a/src/getopt_long.h b/src/getopt_long.h
new file mode 100644
index 00000000..7cd333ea
--- /dev/null
+++ b/src/getopt_long.h
@@ -0,0 +1,65 @@
+/*	$NetBSD: getopt.h,v 1.4 2000/07/07 10:43:54 ad Exp $	*/
+
+/*-
+ * Copyright (c) 2000 The NetBSD Foundation, Inc.
+ * All rights reserved.
+ *
+ * This code is derived from software contributed to The NetBSD Foundation
+ * by Dieter Baron and Thomas Klausner.
+ *
+ * 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 NetBSD
+ *        Foundation, Inc. and its contributors.
+ * 4. Neither the name of The NetBSD Foundation 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 NETBSD FOUNDATION, INC. 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 FOUNDATION 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.
+ */
+
+#ifndef _GETOPT_LONG_H_
+#define _GETOPT_LONG_H_
+
+/*
+ * Gnu like getopt_long() and BSD4.4 getsubopt()/optreset extensions
+ */
+#define no_argument 0
+#define required_argument 1
+#define optional_argument 2
+
+struct option {
+    /* name of long option */
+    const char *name;
+    /*
+     * one of no_argument, required_argument, and optional_argument:
+     * whether option takes an argument
+     */
+    int has_arg;
+    /* if not NULL, set *flag to val when option found */
+    int *flag;
+    /* if flag not NULL, value to set *flag to; else return value */
+    int val;
+};
+
+int getopt_long(int, char *const *, const char *, const struct option *, int *);
+
+#endif /* !_GETOPT_LONG_H_ */
diff --git a/src/getprogname.cc b/src/getprogname.cc
new file mode 100644
index 00000000..1a465599
--- /dev/null
+++ b/src/getprogname.cc
@@ -0,0 +1,54 @@
+/*
+  getprogname.c -- getprogname/setprogname replacement
+  Copyright (C) 2007-2014 Dieter Baron and Thomas Klausner
+
+  This file is part of ckmame, a program to check rom sets for MAME.
+  The authors can be contacted at <ckmame@nih.at>
+
+  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. The name of the author may not be used to endorse or promote
+     products derived from this software without specific prior
+     written permission.
+
+  THIS SOFTWARE IS PROVIDED BY THE AUTHORS ``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 AUTHORS 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 <string.h>
+
+#include "compat.h"
+
+static const char *progname;
+
+
+const char *
+getprogname(void) {
+    return progname;
+}
+
+
+void
+setprogname(const char *name) {
+    if ((progname = strrchr(name, '/')) == NULL)
+	progname = name;
+    else
+	progname++;
+}