acpc_dealer 2.4.1 → 3.0.0

data/vendor/project_acpc_server/kuhn_3p_equilibrium_player/vendor/cexception/lib/CException.c

@@ -1,43 +0,0 @@
-#include "CException.h"
-
-volatile CEXCEPTION_FRAME_T CExceptionFrames[CEXCEPTION_NUM_ID] = { 0 };
-
-//------------------------------------------------------------------------------------------
-//  Throw
-//------------------------------------------------------------------------------------------
-void Throw(CEXCEPTION_T ExceptionID)
-{
-    unsigned int MY_ID = CEXCEPTION_GET_ID;
-    CExceptionFrames[MY_ID].Exception = ExceptionID;
-    if (CExceptionFrames[MY_ID].pFrame)
-    {
-        longjmp(*CExceptionFrames[MY_ID].pFrame, 1);
-    }
-    CEXCEPTION_NO_CATCH_HANDLER(MY_ID);
-}
-
-//------------------------------------------------------------------------------------------
-//  Explanation of what it's all for:
-//------------------------------------------------------------------------------------------
-/*
-#define Try                                                         
-    {                                                                   <- give us some local scope.  most compilers are happy with this
-        jmp_buf *PrevFrame, NewFrame;                                   <- prev frame points to the last try block's frame.  new frame gets created on stack for this Try block
-        unsigned int MY_ID = CEXCEPTION_GET_ID;                         <- look up this task's id for use in frame array.  always 0 if single-tasking
-        PrevFrame = CExceptionFrames[CEXCEPTION_GET_ID].pFrame;         <- set pointer to point at old frame (which array is currently pointing at)
-        CExceptionFrames[MY_ID].pFrame = &NewFrame;                     <- set array to point at my new frame instead, now
-        CExceptionFrames[MY_ID].Exception = CEXCEPTION_NONE;            <- initialize my exception id to be NONE
-        if (setjmp(NewFrame) == 0) {                                    <- do setjmp.  it returns 1 if longjump called, otherwise 0
-            if (&PrevFrame)                                             <- this is here to force proper scoping.  it requires braces or a single line to be but after Try, otherwise won't compile.  This is always true at this point.
-
-#define Catch(e)                                                    
-            else { }                                                    <- this also forces proper scoping.  Without this they could stick their own 'else' in and it would get ugly
-            CExceptionFrames[MY_ID].Exception = CEXCEPTION_NONE;        <- no errors happened, so just set the exception id to NONE (in case it was corrupted)
-        }                                                           
-        else                                                            <- an exception occurred
-        { e = CExceptionFrames[MY_ID].Exception; e=e;}                  <- assign the caught exception id to the variable passed in.  
-        CExceptionFrames[MY_ID].pFrame = PrevFrame;                     <- make the pointer in the array point at the previous frame again, as if NewFrame never existed.
-    }                                                                   <- finish off that local scope we created to have our own variables
-    if (CExceptionFrames[CEXCEPTION_GET_ID].Exception != CEXCEPTION_NONE)  <- start the actual 'catch' processing if we have an exception id saved away
- */
-

data/vendor/project_acpc_server/kuhn_3p_equilibrium_player/vendor/cexception/lib/CException.h

@@ -1,86 +0,0 @@
-#ifndef _CEXCEPTION_H
-#define _CEXCEPTION_H
-
-#include <setjmp.h>
-
-#ifdef __cplusplus
-extern "C"
-{
-#endif
-
-
-//To Use CException, you have a number of options:
-//1. Just include it and run with the defaults
-//2. Define any of the following symbols at the command line to override them
-//3. Include a header file before CException.h everywhere which defines any of these
-//4. Create an Exception.h in your path, and just define EXCEPTION_USE_CONFIG_FILE first
-
-#ifdef CEXCEPTION_USE_CONFIG_FILE
-#include "CExceptionConfig.h"
-#endif
-
-//This is the value to assign when there isn't an exception
-#ifndef CEXCEPTION_NONE
-#define CEXCEPTION_NONE      (0x5A5A5A5A)
-#endif
-
-//This is number of exception stacks to keep track of (one per task)
-#ifndef CEXCEPTION_NUM_ID
-#define CEXCEPTION_NUM_ID    (1) //there is only the one stack by default
-#endif
-
-//This is the method of getting the current exception stack index (0 if only one stack)
-#ifndef CEXCEPTION_GET_ID
-#define CEXCEPTION_GET_ID    (0) //use the first index always because there is only one anyway
-#endif
-
-//The type to use to store the exception values.
-#ifndef CEXCEPTION_T
-#define CEXCEPTION_T         unsigned int
-#endif
-
-//This is an optional special handler for when there is no global Catch
-#ifndef CEXCEPTION_NO_CATCH_HANDLER
-#define CEXCEPTION_NO_CATCH_HANDLER(id)
-#endif
-
-//exception frame structures
-typedef struct {
-  jmp_buf* pFrame;
-  CEXCEPTION_T volatile Exception;
-} CEXCEPTION_FRAME_T;
-
-//actual root frame storage (only one if single-tasking)
-extern volatile CEXCEPTION_FRAME_T CExceptionFrames[];
-
-//Try (see C file for explanation)
-#define Try                                                         \
-    {                                                               \
-        jmp_buf *PrevFrame, NewFrame;                               \
-        unsigned int MY_ID = CEXCEPTION_GET_ID;                     \
-        PrevFrame = CExceptionFrames[CEXCEPTION_GET_ID].pFrame;     \
-        CExceptionFrames[MY_ID].pFrame = (jmp_buf*)(&NewFrame);     \
-        CExceptionFrames[MY_ID].Exception = CEXCEPTION_NONE;        \
-        if (setjmp(NewFrame) == 0) {                                \
-            if (1)
-
-//Catch (see C file for explanation)
-#define Catch(e)                                                    \
-            else { }                                                \
-            CExceptionFrames[MY_ID].Exception = CEXCEPTION_NONE;    \
-        }                                                           \
-        else                                                        \
-        { e = CExceptionFrames[MY_ID].Exception; e=e; }             \
-        CExceptionFrames[MY_ID].pFrame = PrevFrame;                 \
-    }                                                               \
-    if (CExceptionFrames[CEXCEPTION_GET_ID].Exception != CEXCEPTION_NONE)
-
-//Throw an Error
-void Throw(CEXCEPTION_T ExceptionID);
-
-#ifdef __cplusplus
-}   // extern "C"
-#endif
-
-
-#endif // _CEXCEPTION_H

data/vendor/project_acpc_server/kuhn_3p_equilibrium_player/vendor/cexception/release/build.info

@@ -1,2 +0,0 @@
-16
-

data/vendor/project_acpc_server/kuhn_3p_equilibrium_player/vendor/cexception/release/version.info

@@ -1,2 +0,0 @@
-1.2
-

data/vendor/project_acpc_server/kuhn_3p_equilibrium_player/vendor/commander.c/History.md

@@ -1,27 +0,0 @@
-
-1.2.1 / 2013-01-08 
-==================
-
-  * add freeing of normalized argv
-  * dont worry about zeroing in command_free()
-  * fix docs
-
-1.2.0 / 2013-01-08 
-==================
-
-  * add command_free()
-
-1.1.0 / 2012-12-18 
-==================
-
-  * add short flag expansion
-
-1.0.0 / 2012-12-13 
-==================
-
-  * fix malloc(), add a byte for nul
- 
-0.0.1 / 2012-06-16 
-==================
-
-  * Initial release

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

@@ -1,8 +0,0 @@
-
-test: test.c src/commander.c
-	$(CC) $^ -std=c99 -o $@
-
-clean:
-	rm -f test
-
-.PHONY: clean

data/vendor/project_acpc_server/kuhn_3p_equilibrium_player/vendor/commander.c/Readme.md

@@ -1,103 +0,0 @@
-
-# commander.c
-
-  Commander option parser ported to C.
-
-## Automated --help
-
-  The previous example would produce the following `--help`:
-
-```
-
-Usage: example [options]
-
-Options:
-
-  -V, --version                 output program version
-  -h, --help                    output help information
-  -v, --verbose                 enable verbose stuff
-  -r, --required <arg>          required arg
-  -o, --optional [arg]          optional arg
-
-```
-
-## Example
-
-```c
-#include <stdio.h>
-#include "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, const 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;
-}
-```
-
-## Closure
-
-  `cmd.data` is a `void *` so pass along a struct to the callbacks if you want.
-
-## Usage
-
-  `cmd.usage` defaults to "[options]".
-
-## Links
-
-  - Used by the [mon(1)](https://github.com/visionmedia/mon/blob/master/src/mon.c) process monitor
-
-## Short flags
-
-  Compound short flags are automatically expanded to their canonical form. For example `-vLO` would
-  become `-v -L -O`.
-
-## License
-
-(The MIT License)
-
-Copyright (c) 2012 TJ Holowaychuk &lt;tj@vision-media.ca&gt;
-
-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.
-

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

@@ -1,9 +0,0 @@
-{
-  "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

@@ -1,250 +0,0 @@
-
-//
-// 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);
-}