Added dep clibs/commander for command line parsing

CMakeLists.txt

@@ -23,6 +23,7 @@ endif()
 
 # Include directories
 include_directories ("${PROJECT_SOURCE_DIR}/include")
+include_directories ("${PROJECT_SOURCE_DIR}/src/deps")
 include_directories ("${PROJECT_BINARY_DIR}")
 
 # Include External Modules

README.md

@@ -171,3 +171,5 @@ See the respective files in `cmake` for their licensing.
 * Copyright 2003-2009 Kitware, Inc.
 * Eric Wing
 
+The [clibs/commander](https://github.com/clibs/commander) dependency is Copyright (c) 2012 TJ Holowaychuk (tj@vision-media.ca) and licensed under the [MIT License](http://opensource.org/licenses/MIT).
+

TODO.md

@@ -11,6 +11,7 @@
     * Rewrite Console and use operator << to write to the console?
 * Mesh has 2 different approaches of storing the same data (eg. mColors and mColorArray), but half of ‘em isn’t implemented. Unify this, probably even combining Mesh and StaticMesh...
 * Don’t use float everywhere just because (eg. float colors)
+* Add verbose command line flag for debug output also in release builds
 
 ## Cmake
 

src/CMakeLists.txt

@@ -202,6 +202,7 @@ set (CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} ${OpenRaider_CXX_FLAGS} ${O
 set (CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} ${OpenRaider_CXX_FLAGS} ${OpenRaider_CXX_FLAGS_RELEASE}")
 
 # Add subdirectories
+add_subdirectory ("deps")
 add_subdirectory ("math")
 add_subdirectory ("utils")
 
@@ -257,6 +258,7 @@ if (UNIX)
 endif (UNIX)
 
 # Add utils Library
+set (LIBS ${LIBS} OpenRaider_deps)
 set (LIBS ${LIBS} OpenRaider_math)
 set (LIBS ${LIBS} OpenRaider_utils)
 
@@ -268,4 +270,5 @@ target_link_libraries (OpenRaider ${LIBS})
 # Add target to run executable
 if (${CMAKE_GENERATOR} STREQUAL "Unix Makefiles" OR ${CMAKE_GENERATOR} STREQUAL "MinGW Makefiles")
     add_custom_target(run COMMAND OpenRaider DEPENDS OpenRaider WORKING_DIRECTORY ${CMAKE_PROJECT_DIR})
-endif (${CMAKE_GENERATOR} STREQUAL "Unix Makefiles" OR ${CMAKE_GENERATOR} STREQUAL "MinGW Makefiles") 
+endif (${CMAKE_GENERATOR} STREQUAL "Unix Makefiles" OR ${CMAKE_GENERATOR} STREQUAL "MinGW Makefiles")
+

src/deps/CMakeLists.txt

@@ -0,0 +1,6 @@
+# Source files
+set (DEPS_SRCS ${DEPS_SRCS} "commander/commander.c")
+
+# Add library
+add_library (OpenRaider_deps ${DEPS_SRCS})
+

src/deps/commander/commander.c

@@ -0,0 +1,269 @@
+
+//
+// commander.c
+//
+// Copyright (c) 2012 TJ Holowaychuk <tj@vision-media.ca>
+//
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <assert.h>
+#include "commander.h"
+
+/*
+ * Output error and exit.
+ */
+
+static void
+error(char *msg) {
+  fprintf(stderr, "%s\n", msg);
+  exit(1);
+}
+
+/*
+ * Output command version.
+ */
+
+static void
+command_version(command_t *self) {
+  printf("%s\n", self->version);
+  command_free(self);
+  exit(0);
+}
+
+/*
+ * Output command help.
+ */
+
+void
+command_help(command_t *self) {
+  printf("\n");
+  printf("  Usage: %s %s\n", self->name, self->usage);
+  printf("\n");
+  printf("  Options:\n");
+  printf("\n");
+
+  int i;
+  for (i = 0; i < self->option_count; ++i) {
+    command_option_t *option = &self->options[i];
+    printf("    %s, %-25s %s\n"
+      , option->small
+      , option->large_with_arg
+      , option->description);
+  }
+
+  printf("\n");
+  command_free(self);
+  exit(0);
+}
+
+/*
+ * Initialize with program `name` and `version`.
+ */
+
+void
+command_init(command_t *self, const char *name, const char *version) {
+  self->arg = NULL;
+  self->name = name;
+  self->version = version;
+  self->option_count = self->argc = 0;
+  self->usage = "[options]";
+  self->nargv = NULL;
+  command_option(self, "-V", "--version", "output program version", command_version);
+  command_option(self, "-h", "--help", "output help information", command_help);
+}
+
+/*
+ * Free up commander after use.
+ */
+
+void
+command_free(command_t *self) {
+  int i;
+
+  for (i = 0; i < self->option_count; ++i) {
+    command_option_t *option = &self->options[i];
+    free(option->argname);
+    free(option->large);
+  }
+
+  if (self->nargv) {
+    for (i = 0; self->nargv[i]; ++i) {
+      free(self->nargv[i]);
+    }
+    free(self->nargv);
+  }
+}
+
+/*
+ * Parse argname from `str`. For example
+ * Take "--required <arg>" and populate `flag`
+ * with "--required" and `arg` with "<arg>".
+ */
+
+static void
+parse_argname(const char *str, char *flag, char *arg) {
+  int buffer = 0;
+  size_t flagpos = 0;
+  size_t argpos = 0;
+  size_t len = strlen(str);
+  size_t i;
+
+  for (i = 0; i < len; ++i) {
+    if (buffer || '[' == str[i] || '<' == str[i]) {
+      buffer = 1;
+      arg[argpos++] = str[i];
+    } else {
+      if (' ' == str[i]) continue;
+      flag[flagpos++] = str[i];
+    }
+  }
+
+  arg[argpos] = '\0';
+  flag[flagpos] = '\0';
+}
+
+/*
+ * Normalize the argument vector by exploding
+ * multiple options (if any). For example
+ * "foo -abc --scm git" -> "foo -a -b -c --scm git"
+ */
+
+static char **
+normalize_args(int *argc, char **argv) {
+  int size = 0;
+  int alloc = *argc + 1;
+  char **nargv = malloc(alloc * sizeof(char *));
+  int i;
+
+  for (i = 0; argv[i]; ++i) {
+    const char *arg = argv[i];
+    size_t len = strlen(arg);
+
+    // short flag
+    if (len > 2 && '-' == arg[0] && !strchr(arg + 1, '-')) {
+      alloc += len - 2;
+      nargv = realloc(nargv, alloc * sizeof(char *));
+      for (size_t j = 1; j < len; ++j) {
+        nargv[size] = malloc(3);
+        sprintf(nargv[size], "-%c", arg[j]);
+        size++;
+      }
+      continue;
+    }
+
+    // regular arg
+    nargv[size] = malloc(len + 1);
+    strcpy(nargv[size], arg);
+    size++;
+  }
+
+  nargv[size] = NULL;
+  *argc = size;
+  return nargv;
+}
+
+/*
+ * Define an option.
+ */
+
+void
+command_option(command_t *self, const char *small, const char *large, const char *desc, command_callback_t cb) {
+  if (self->option_count == COMMANDER_MAX_OPTIONS) {
+    command_free(self);
+    error("Maximum option definitions exceeded");
+  }
+  int n = self->option_count++;
+  command_option_t *option = &self->options[n];
+  option->cb = cb;
+  option->small = small;
+  option->description = desc;
+  option->required_arg = option->optional_arg = 0;
+  option->large_with_arg = large;
+  option->argname = malloc(strlen(large) + 1);
+  assert(option->argname);
+  option->large = malloc(strlen(large) + 1);
+  assert(option->large);
+  parse_argname(large, option->large, option->argname);
+  if ('[' == option->argname[0]) option->optional_arg = 1;
+  if ('<' == option->argname[0]) option->required_arg = 1;
+}
+
+/*
+ * Parse `argv` (internal).
+ * Input arguments should be normalized first
+ * see `normalize_args`.
+ */
+
+static void
+command_parse_args(command_t *self, int argc, char **argv) {
+  int literal = 0;
+  int i, j;
+
+  for (i = 1; i < argc; ++i) {
+    const char *arg = argv[i];
+    for (j = 0; j < self->option_count; ++j) {
+      command_option_t *option = &self->options[j];
+
+      // match flag
+      if (!strcmp(arg, option->small) || !strcmp(arg, option->large)) {
+        self->arg = NULL;
+
+        // required
+        if (option->required_arg) {
+          arg = argv[++i];
+          if (!arg || '-' == arg[0]) {
+            fprintf(stderr, "%s %s argument required\n", option->large, option->argname);
+            command_free(self);
+            exit(1);
+          }
+          self->arg = arg;
+        }
+
+        // optional
+        if (option->optional_arg) {
+          if (argv[i + 1] && '-' != argv[i + 1][0]) {
+            self->arg = argv[++i];
+          }
+        }
+
+        // invoke callback
+        option->cb(self);
+        goto match;
+      }
+    }
+
+    // --
+    if ('-' == arg[0] && '-' == arg[1] && 0 == arg[2]) {
+      literal = 1;
+      goto match;
+    }
+
+    // unrecognized
+    if ('-' == arg[0] && !literal) {
+      fprintf(stderr, "unrecognized flag %s\n", arg);
+      command_free(self);
+      exit(1);
+    }
+
+    int n = self->argc++;
+    if (n == COMMANDER_MAX_ARGS) {
+      command_free(self);
+      error("Maximum number of arguments exceeded");
+    }
+    self->argv[n] = (char *) arg;
+    match:;
+  }
+}
+
+/*
+ * Parse `argv` (public).
+ */
+
+void
+command_parse(command_t *self, int argc, char **argv) {
+  self->nargv = normalize_args(&argc, argv);
+  command_parse_args(self, argc, self->nargv);
+  self->argv[self->argc] = NULL;
+}

src/deps/commander/commander.h

@@ -0,0 +1,96 @@
+
+//
+// commander.h
+//
+// Copyright (c) 2012 TJ Holowaychuk <tj@vision-media.ca>
+//
+
+#ifndef COMMANDER_H
+#define COMMANDER_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+ * Max options that can be defined.
+ */
+
+#ifndef COMMANDER_MAX_OPTIONS
+#define COMMANDER_MAX_OPTIONS 32
+#endif
+
+/*
+ * Max arguments that can be passed.
+ */
+
+#ifndef COMMANDER_MAX_ARGS
+#define COMMANDER_MAX_ARGS 32
+#endif
+
+/*
+ * Command struct.
+ */
+
+struct command;
+
+/*
+ * Option callback.
+ */
+
+typedef void (* command_callback_t)(struct command *self);
+
+/*
+ * Command option.
+ */
+
+typedef struct {
+  int optional_arg;
+  int required_arg;
+  char *argname;
+  char *large;
+  const char *small;
+  const char *large_with_arg;
+  const char *description;
+  command_callback_t cb;
+} command_option_t;
+
+/*
+ * Command.
+ */
+
+typedef struct command {
+  void *data;
+  const char *usage;
+  const char *arg;
+  const char *name;
+  const char *version;
+  int option_count;
+  command_option_t options[COMMANDER_MAX_OPTIONS];
+  int argc;
+  char *argv[COMMANDER_MAX_ARGS];
+  char **nargv;
+} command_t;
+
+// prototypes
+
+void
+command_init(command_t *self, const char *name, const char *version);
+
+void
+command_free(command_t *self);
+
+void
+command_help(command_t *self);
+
+void
+command_option(command_t *self, const char *small, const char *large, const char *desc, command_callback_t cb);
+
+void
+command_parse(command_t *self, int argc, char **argv);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* COMMANDER_H */

src/deps/commander/package.json

@@ -0,0 +1,9 @@
+{
+  "name": "commander",
+  "version": "1.3.2",
+  "repo": "clibs/commander",
+  "description": "Command-line argument parser",
+  "keywords": ["cli", "command", "parser", "argv", "args", "options"],
+  "license": "MIT",
+  "src": ["src/commander.h", "src/commander.c"]
+}

src/main.cpp

@@ -19,6 +19,7 @@
 #include "Render.h"
 #include "TextureManager.h"
 #include "World.h"
+#include "commander/commander.h"
 #include "utils/strings.h"
 #include "utils/time.h"
 
@@ -34,8 +35,6 @@
 #error No Windowing Library selected!
 #endif
 
-void cleanupHandler(void);
-
 Camera &getCamera() {
     static Camera gCamera;
     return gCamera;
@@ -97,7 +96,7 @@ World &getWorld() {
     return gWorld;
 }
 
-void cleanupHandler(void) {
+static void cleanupHandler(void) {
 #ifdef DEBUG
     std::cout << std::endl;
     std::cout << "Thanks for testing " << VERSION << std::endl;
@@ -108,38 +107,23 @@ void cleanupHandler(void) {
 #endif
 }
 
+static bool configFileWasSpecified = false;
+static void configFileCallback(command_t *self) {
+    getOpenRaider().loadConfig(self->arg);
+    configFileWasSpecified = true;
+}
+
 int main(int argc, char *argv[]) {
-    bool configArg = false;
-
-    // Handle arguments
-    if (argc == 2) {
-        // Check for command line switches
-        if ((strcmp("-h", argv[1]) == 0)
-                || (strcmp("--help", argv[1]) == 0)) {
-            // Display help text
-            std::cout << argv[0] << " [OPTIONS | /path/to/config]" << std::endl;
-            std::cout << "Options:" << std::endl;
-            std::cout << "\t--help" << std::endl;
-            std::cout << "\t-h\tDisplay this help text" << std::endl;
-            std::cout << "\t--version" << std::endl;
-            std::cout << "\t-v\tDisplay version information" << std::endl;
-            std::cout << "If no options are given, the default config will be loaded from:" << std::endl;
-            std::cout << "\t" << DEFAULT_CONFIG_FILE << std::endl;
-            std::cout << "or" << std::endl;
-            std::cout << "\t" << DEFAULT_CONFIG_PATH << "/" << DEFAULT_CONFIG_FILE << std::endl;
-            return 0;
-        } else if ((strcmp("-v", argv[1]) == 0)
-                || (strcmp("--version", argv[1]) == 0)) {
-            // Display version
-            std::cout << VERSION << std::endl;
-            return 0;
-        } else {
-            configArg = true;
+    command_t cmd;
+    command_init(&cmd, argv[0], VERSION);
+    //command_option(&cmd, "-v", "--verbose", "enable verbose output", functionPointer);
+    command_option(&cmd, "-c", "--config <file>", "select config file to use", configFileCallback);
+    command_parse(&cmd, argc, argv);
+
+    if (!configFileWasSpecified) {
+        if (getOpenRaider().loadConfig(DEFAULT_CONFIG_FILE) != 0) {
+            getOpenRaider().loadConfig(DEFAULT_CONFIG_PATH "/" DEFAULT_CONFIG_FILE);
         }
-    } else if (argc > 2) {
-        std::cout << "Usage:" << std::endl;
-        std::cout << argv[0] << " -h" << std::endl;
-        return 1;
     }
 
 #ifdef DEBUG
@@ -148,29 +132,14 @@ int main(int argc, char *argv[]) {
 
     atexit(cleanupHandler);
 
-    // Try to load a configuration
-    if (configArg) {
-        if (getOpenRaider().loadConfig(argv[1]) != 0) {
-            std::cout << "Could not find the specified config file. Aborting..." << std::endl;
-            return 2;
-        }
-    } else {
-        if (getOpenRaider().loadConfig(DEFAULT_CONFIG_FILE) != 0) {
-            if (getOpenRaider().loadConfig(DEFAULT_CONFIG_PATH "/" DEFAULT_CONFIG_FILE) != 0) {
-                std::cout << "Could not find a config file. Aborting..." << std::endl;
-                return 3;
-            }
-        }
-    }
-
-    // Initialize everything
     int error = getOpenRaider().initialize();
     if (error != 0) {
         std::cout << "Could not initialize OpenRaider (" << error << ")!" << std::endl;
-        return 4;
+        return 2;
     }
 
-    // Enter Main loop
+    command_free(&cmd);
+
     getConsole().print("Starting %s", VERSION);
     getOpenRaider().run();
 

src/math/CMakeLists.txt

@@ -4,8 +4,6 @@ set (MATH_SRCS ${MATH_SRCS} "Matrix.cpp")
 set (MATH_SRCS ${MATH_SRCS} "Quaternion.cpp")
 set (MATH_SRCS ${MATH_SRCS} "Vector3d.cpp")
 
-# Include directory
-include_directories ("${PROJECT_SOURCE_DIR}/include")
-
 # Add library
 add_library (OpenRaider_math ${MATH_SRCS})
+

src/utils/CMakeLists.txt

@@ -10,8 +10,6 @@ if (USING_PNG)
     set (UTIL_SRCS ${UTIL_SRCS} "png.cpp")
 endif (USING_PNG)
 
-# Include directory
-include_directories ("${PROJECT_SOURCE_DIR}/include")
-
 # Add library
 add_library (OpenRaider_utils ${UTIL_SRCS})
+