acpc_dealer 2.0.6 → 2.1.0

data/vendor/project_acpc_server/kuhn_3p_equilibrium_player/vendor/commander.c/package.json

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

data/vendor/project_acpc_server/kuhn_3p_equilibrium_player/vendor/commander.c/src/commander.c

@@ -0,0 +1,250 @@
+
+//
+// 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);
+  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");
+  for (int 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");
+  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) {
+  for (int i = 0; i < self->option_count; ++i) {
+    command_option_t *option = &self->options[i];
+    free(option->argname);
+    free(option->large);
+  }
+
+  if (self->nargv) {
+    for (int 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);
+
+  for (int 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 *));
+
+  for (int i = 0; argv[i]; ++i) {
+    const char *arg = argv[i];
+    int len = strlen(arg);
+
+    // short flag
+    if (len > 2 && '-' == arg[0] && !strchr(arg + 1, '-')) {
+      alloc += len - 2;
+      nargv = realloc(nargv, alloc * sizeof(char *));
+      for (int 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) {
+  int n = self->option_count++;
+  if (n == COMMANDER_MAX_OPTIONS) error("Maximum option definitions exceeded");
+  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;
+
+  for (int i = 1; i < argc; ++i) {
+    const char *arg = argv[i];
+    for (int 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);
+            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);
+      exit(1);
+    }
+
+    int n = self->argc++;
+    if (n == COMMANDER_MAX_ARGS) 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);
+}

data/vendor/project_acpc_server/kuhn_3p_equilibrium_player/vendor/commander.c/src/commander.h

@@ -0,0 +1,88 @@
+
+//
+// commander.h
+//
+// Copyright (c) 2012 TJ Holowaychuk <tj@vision-media.ca>
+//
+
+#ifndef COMMANDER_H
+#define COMMANDER_H
+
+/*
+ * 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);
+
+#endif /* COMMANDER_H */

data/vendor/project_acpc_server/kuhn_3p_equilibrium_player/vendor/commander.c/test.c

@@ -0,0 +1,34 @@
+
+#include <stdio.h>
+#include "src/commander.h"
+
+static void
+verbose(command_t *self) {
+  printf("verbose: enabled\n");
+}
+
+static void
+required(command_t *self) {
+  printf("required: %s\n", self->arg);
+}
+
+static void
+optional(command_t *self) {
+  printf("optional: %s\n", self->arg);
+}
+
+int
+main(int argc, char **argv){
+  command_t cmd;
+  command_init(&cmd, argv[0], "0.0.1");
+  command_option(&cmd, "-v", "--verbose", "enable verbose stuff", verbose);
+  command_option(&cmd, "-r", "--required <arg>", "required arg", required);
+  command_option(&cmd, "-o", "--optional [arg]", "optional arg", optional);
+  command_parse(&cmd, argc, argv);
+  printf("additional args:\n");
+  for (int i = 0; i < cmd.argc; ++i) {
+    printf("  - '%s'\n", cmd.argv[i]);
+  }
+  command_free(&cmd);
+  return 0;
+}

data/vendor/project_acpc_server/kuhn_3p_equilibrium_player/vendor/unity/auto/colour_prompt.rb

@@ -0,0 +1,94 @@
+# ==========================================
+#   Unity Project - A Test Framework for C
+#   Copyright (c) 2007 Mike Karlesky, Mark VanderVoord, Greg Williams
+#   [Released under MIT License. Please refer to license.txt for details]
+# ========================================== 
+
+if RUBY_PLATFORM =~/(win|w)32$/
+	begin
+		require 'Win32API'
+	rescue LoadError
+		puts "ERROR! \"Win32API\" library not found"
+		puts "\"Win32API\" is required for colour on a windows machine"
+		puts "  try => \"gem install Win32API\" on the command line"
+		puts
+	end
+	# puts
+  # puts 'Windows Environment Detected...'
+	# puts 'Win32API Library Found.'
+	# puts
+end
+
+class ColourCommandLine
+  def initialize
+    if RUBY_PLATFORM =~/(win|w)32$/  
+      get_std_handle = Win32API.new("kernel32", "GetStdHandle", ['L'], 'L')
+      @set_console_txt_attrb =
+      Win32API.new("kernel32","SetConsoleTextAttribute",['L','N'], 'I')
+      @hout = get_std_handle.call(-11)
+    end
+  end
+  
+  def change_to(new_colour)
+    if RUBY_PLATFORM =~/(win|w)32$/
+      @set_console_txt_attrb.call(@hout,self.win32_colour(new_colour))
+    else
+	  	"\033[30;#{posix_colour(new_colour)};22m"
+	 	end
+  end
+  
+  def win32_colour(colour)
+    case colour
+      when :black then 0  
+      when :dark_blue then 1
+      when :dark_green then 2
+      when :dark_cyan then 3
+      when :dark_red then 4
+      when :dark_purple then 5
+      when :dark_yellow, :narrative then 6
+      when :default_white, :default, :dark_white then 7
+      when :silver then 8
+      when :blue then 9
+      when :green, :success then 10
+      when :cyan, :output then 11
+      when :red, :failure then 12
+      when :purple then 13
+      when :yellow then 14
+      when :white then 15
+      else
+        0
+    end
+  end
+	
+	def posix_colour(colour)
+	  case colour
+      when :black then 30  
+      when :red, :failure then 31
+      when :green, :success then 32
+			when :yellow then 33
+      when :blue, :narrative then 34
+      when :purple, :magenta then 35
+      when :cyan, :output then 36
+      when :white, :default_white, :default then 37
+      else
+        30
+    end
+  end
+	
+  def out_c(mode, colour, str)
+    case RUBY_PLATFORM
+			when /(win|w)32$/
+			  change_to(colour)
+				 $stdout.puts str if mode == :puts
+				 $stdout.print str if mode == :print
+			  change_to(:default_white)
+			else
+				$stdout.puts("#{change_to(colour)}#{str}\033[0m") if mode == :puts
+				$stdout.print("#{change_to(colour)}#{str}\033[0m") if mode == :print
+		end			
+  end
+end # ColourCommandLine
+
+def colour_puts(role,str)  ColourCommandLine.new.out_c(:puts, role, str)  end
+def colour_print(role,str) ColourCommandLine.new.out_c(:print, role, str) end
+