acpc_dealer 2.0.6 → 2.1.0

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

@@ -0,0 +1,43 @@
+#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

@@ -0,0 +1,86 @@
+#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

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

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

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

data/vendor/project_acpc_server/kuhn_3p_equilibrium_player/vendor/cmock/config/production_environment.rb

@@ -0,0 +1,14 @@
+# ==========================================
+#   CMock Project - Automatic Mock Generation for C
+#   Copyright (c) 2007 Mike Karlesky, Mark VanderVoord, Greg Williams
+#   [Released under MIT License. Please refer to license.txt for details]
+# ========================================== 
+ 
+# Setup our load path:
+[ 
+ 'lib',
+].each do |dir|
+  $LOAD_PATH.unshift( File.join( File.expand_path(File.dirname(__FILE__)) + '/../', dir) )
+end
+
+

data/vendor/project_acpc_server/kuhn_3p_equilibrium_player/vendor/cmock/config/test_environment.rb

@@ -0,0 +1,16 @@
+# ==========================================
+#   CMock Project - Automatic Mock Generation for C
+#   Copyright (c) 2007 Mike Karlesky, Mark VanderVoord, Greg Williams
+#   [Released under MIT License. Please refer to license.txt for details]
+# ========================================== 
+
+# Setup our load path:
+[ 
+  'lib',
+  'vendor/behaviors/lib',
+  'vendor/hardmock/lib',
+  'vendor/unity/auto/',
+  'test/system/'
+].each do |dir|
+  $LOAD_PATH.unshift( File.join( File.expand_path(File.dirname(__FILE__) + "/../"), dir) )
+end

data/vendor/project_acpc_server/kuhn_3p_equilibrium_player/vendor/cmock/docs/CMock_Summary.md

@@ -0,0 +1,356 @@
+[All code is copyright © 2007-2010 Cmock Project
+by Mike Karlesky, Mark VanderVoord, and Greg Williams.
+
+This Documentation Is Released Under a Creative Commons 3.0 
+Attribution Share-Alike License] 
+
+
+What the What?
+==============
+
+CMock is a nice little tool which takes your header files and creates 
+a Mock interface for it so that you can more easily Unit test modules 
+that touch other modules. For each function prototype in your 
+header, like this one: 
+
+    int DoesSomething(int a, int b);
+    
+
+...you get an automatically generated DoesSomething function 
+that you can link to instead of your real DoesSomething function. 
+By using this Mocked version, you can then verify that it receives 
+the data you want, and make it return whatever data you desire, 
+make it throw errors when you want, and more... Create these for 
+everything your latest real module touches, and you're suddenly 
+in a position of power: You can control and verify every detail 
+of your latest creation. 
+
+To make that easier, CMock also gives you a bunch of functions 
+like the ones below, so you can tell that generated DoesSomething 
+function how to behave for each test: 
+
+    void DoesSomething_ExpectAndReturn(int a, int b, int toReturn);
+    void DoesSomething_ExpectAndThrow(int a, int b, EXCEPTION_T error);
+    void DoesSomething_StubWithCallback(CMOCK_DoesSomething_CALLBACK YourCallback);
+    void DoesSomething_IgnoreAndReturn(int toReturn);
+    
+
+You can pile a bunch of these back to back, and it remembers what 
+you wanted to pass when, like so: 
+
+    test_CallsDoesSomething_ShouldDoJustThat(void)
+    {
+        DoesSomething_ExpectAndReturn(1,2,3);
+        DoesSomething_ExpectAndReturn(4,5,6);
+        DoesSomething_ExpectAndThrow(7,8, STATUS_ERROR_OOPS);
+    
+        CallsDoesSomething( );
+    }
+    
+
+This test will call CallsDoesSomething, which is the function 
+we are testing. We are expecting that function to call DoesSomething 
+three times. The first time, we check to make sure it's called 
+as DoesSomething(1, 2) and we'll magically return a 3. The second 
+time we check for DoesSomething(4, 5) and we'll return a 6. The 
+third time we verify DoesSomething(7, 8) and we'll throw an error 
+instead of returning anything. If CallsDoesSomething gets 
+any of this wrong, it fails the test. It will fail if you didn't 
+call DoesSomething enough, or too much, or with the wrong arguments, 
+or in the wrong order. 
+
+CMock is based on Unity, which it uses for all internal testing. 
+It uses Ruby to do all the main work (versions 1.8.6 through 1.9.2). 
+
+
+Generated Mock Module Summary
+=============================
+
+In addition to the mocks themselves, CMock will generate the 
+following functions for use in your tests. The expect functions 
+are always generated. The other functions are only generated 
+if those plugins are enabled: 
+
+
+Expect:
+-------
+
+Your basic staple Expects which will be used for most of your day 
+to day CMock work. 
+
+* `void func(void)` => `void func_Expect(void)`
+* `void func(params)` => `void func_Expect(expected_params)`
+* `retval func(void)` => `void func_ExpectAndReturn(retval_to_return)`
+* `retval func(params)` => `void func_ExpectAndReturn(expected_params, retval_to_return)`
+
+
+Array:
+------
+
+An ExpectWithArray will check as many elements as you specify. 
+If you specify zero elements, it will check just the pointer if 
+`:smart` mode is configured or fail if `:compare_data` is set. 
+
+* `void func(void)` => (nothing. In fact, an additional function is only generated if the params list contains pointers)
+* `void func(ptr * param, other)` => `void func_ExpectWithArray(ptr* param, int param_depth, other)`
+* `retval func(void)` => (nothing. In fact, an additional function is only generated if the params list contains pointers)
+* `retval func(other, ptr* param)` => `void func_ExpectWithArrayAndReturn(other, ptr* param, int param_depth, retval_to_return)`
+
+
+Callback:
+---------
+
+As soon as you stub a callback in a test, it will call the callback 
+whenever the mock is encountered and return the retval returned 
+from the callback (if any) instead of performing the usual expect 
+checks. It can be configured to check the arguments first (like 
+expects) or just jump directly to the callback. 
+
+* `void func(void)` => `void func_StubWithCallback(CMOCK_func_CALLBACK callback)`
+where `CMOCK_func_CALLBACK` looks like: `void func(int NumCalls)`
+* `void func(params)` => `void func_StubWithCallback(CMOCK_func_CALLBACK callback)`
+where `CMOCK_func_CALLBACK` looks like: `void func(params, int NumCalls)`
+* `retval func(void)` => `void func_StubWithCallback(CMOCK_func_CALLBACK callback)`
+where `CMOCK_func_CALLBACK` looks like: `retval func(int NumCalls)`
+* `retval func(params)` => `void func_StubWithCallback(CMOCK_func_CALLBACK callback)`
+where `CMOCK_func_CALLBACK` looks like: `retval func(params, int NumCalls)`
+
+
+Cexception:
+-----------
+
+If you are using Cexception for error handling, you can use this 
+to throw errors from inside mocks. Like Expects, it remembers 
+which call was supposed to throw the error, and it still checks 
+parameters. 
+
+* `void func(void)` => `void func_ExpectAndThrow(value_to_throw)`
+* `void func(params)` => `void func_ExpectAndThrow(expected_params, value_to_throw)`
+* `retval func(void)` => `void func_ExpectAndThrow(value_to_throw)`
+* `retval func(params)` => `void func_ExpectAndThrow(expected_params, value_to_throw)`
+
+
+Ignore:
+-------
+
+This plugin supports two modes. You can use it to force CMock to 
+ignore calls to specific functions or to just ignore the arguments 
+passed to those functions. Either way you can specify multiple 
+returns or a single value to always return, whichever you prefer. 
+
+* `void func(void)` => `void func_Ignore(void)`
+* `void func(params)` => `void func_Ignore(void)`
+* `retval func(void)` => `void func_IgnoreAndReturn(retval_to_return)`
+* `retval func(params)` => `void func_IgnoreAndReturn(retval_to_return)`
+
+
+Running CMock
+=============
+
+CMock is a Ruby script and class. You can therefore use it directly 
+from the command line, or include it in your own scripts or rakefiles. 
+
+Mocking from the Command Line
+-----------------------------
+
+After unpacking CMock, you will find CMock.rb in the 'lib' directory. 
+This is the file that you want to run. It takes a list of header files 
+to be mocked, as well as an optional yaml file for a more detailed 
+configuration (see config options below). 
+
+For example, this will create three mocks using the configuration 
+specified in MyConfig.yml: 
+
+    ruby cmock.rb -oMyConfig.yml super.h duper.h awesome.h
+
+And this will create two mocks using the default configuration: 
+
+    ruby cmock.rb ../mocking/stuff/is/fun.h ../try/it/yourself.h
+
+Mocking From Scripts or Rake
+----------------------------
+
+CMock can be used directly from your own scripts or from a rakefile. 
+Start by including cmock.rb, then create an instance of CMock. 
+When you create your instance, you may initialize it in one of 
+three ways. 
+
+You may specify nothing, allowing it to run with default settings: 
+
+    cmock = CMock.new
+
+You may specify a YAML file containing the configuration options 
+you desire: 
+
+    cmock = CMock.new('../MyConfig.yml')
+
+You may specify the options explicitly: 
+
+    cmock = Cmock.new(:plugins => [:cexception, :ignore], :mock_path => 'my/mocks/')
+
+Config Options: 
+
+The following configuration options can be specified in the 
+yaml file or directly when instantiating. 
+
+Passed as Ruby, they look like this: 
+
+        { :attributes => [“__funky”, “__intrinsic”], :when_ptr => :compare }
+
+Defined in the yaml file, they look more like this: 
+
+        :cmock: 
+          :attributes:
+            - __funky
+            - __intrinsic
+          :when_ptr: :compare
+
+
+* `:attributes`:
+  These are attributes that CMock should ignore for you for testing
+  purposes. Custom compiler extensions and externs are handy things to
+  put here.
+
+* `:callback_after_arg_check`:
+  Tell `:callback` plugin to do the normal argument checking before it
+  calls the callback function. This defaults to false, where the
+  callback function is called instead of the argument verification.
+
+* `:callback_include_count`:
+  Tell `:callback` plugin to include an extra parameter to specify the
+  number of times the callback has been called. If set to false, the
+  callback has the same interface as the mocked function. This can be
+  handy when you're wanting to use callback as a stub.
+
+* `:cexception_include`:
+  Tell `:cexception` plugin where to find CException.h... only need to
+  define if it's not in your build path already.
+
+* `:enforce_strict_ordering`:
+  CMock always enforces the order that you call a particular function,
+  so if you expect GrabNabber(int size) to be called three times, it
+  will verify that the sizes are in the order you specified. You might
+  also want to make sure that all different functions are called in a
+  particular order. If so, set this to true.
+
+* `:framework`:
+  Currently the only option is `:unity.` Eventually if we support other
+  unity test frameworks (or if you write one for us), they'll get added
+  here.
+
+* `:ignore`:
+  Tell `:ignore` plugin to ignore `:args_only` or `:args_and_calls`
+  (default) where it doesn't even care how many times the mock was
+  called
+
+* `:includes`:
+  An array of additional include files which should be added to the
+  mocks. Useful for global types and definitions used in your project.
+  There are more specific versions if you care WHERE in the mock files
+  the includes get placed. You can define any or all of
+  `:includes_h_pre_orig_header,` `:includes_h_post_orig_header, `
+  `:includes_c_pre_header,` `:includes_c_post_header
+
+* `:memcmp_if_unknown`:
+  This is true by default. When true, CMock will just do a memory
+  comparison of types that it doesn't recognize (not standard types, not
+  in `:treat_as,` and not in a unity helper). If you instead want it to
+  throw an error, just set this to false.
+
+* `:mock_path`:
+  The directory where you would like the mock files generated to be
+  placed.
+
+* `:mock_prefix`:
+  The prefix to append to your mock files. Defaults to “Mock”, so a file
+  “USART.h” will get a mock called “MockUSART.c”
+
+* `:plugins`:
+  An array of which plugins to enable. 'expect' is always active. Also
+  available currently are `:ignore,` `:array,` `:cexception,` and
+  `:callback:
+
+* `:treat_as`:
+  The `:treat_as` list is a shortcut for when you have created typedefs
+  of standard types. Why create a custom unity helper for UINT16 when
+  the unity function TEST_ASSERT_EQUAL_HEX16 will work just perfectly?
+  Just add 'UINT16' => 'HEX16' to your list (actually, don't. We already
+  did that one for you). Maybe you have a type that is a pointer to an
+  array of unsigned characters? No problem, just add 'UINT8_T*' =>
+  'HEX8*'
+
+* `:treat_as_void`:
+  We've seen "fun" legacy systems typedef 'void' with a custom type,
+  like MY_VOID. Add any instances of those to this list to help CMock
+  understand how to deal with your code.
+
+* `:treat_externs`:
+  Set to `:include` to mock externed functions or `:exclude` to ignore
+  them (the default).
+
+* `:unity_helper_path`:
+  If you have created a header with your own extensions to unity to
+  handle your own types, you can set this argument to that path. CMock
+  will then automagically pull in your helpers and use them. The only
+  trick is that you make sure you follow the naming convention:
+  UNITY_TEST_ASSERT_EQUAL_YourType
+
+* `:verbosity`:
+  0 for errors only. 1 for errors and warnings. 2 for normal. 3 for
+  verbose
+
+* `:when_no_prototypes`:
+  When you give CMock a header file and ask it to create a mock out of
+  it, it usually contains function prototypes (otherwise what was the
+  point?). You can control what happens when this isn't true. You can
+  set this to `:warn,` `:ignore,` or `:error
+
+* `:when_ptr`:
+  You can customize how CMock deals with pointers (c strings result in
+  string comparisons... we're talking about other pointers here). Your
+  options are `:compare_ptr` to just verify the pointers are the same,
+  `:compare_data` or `:smart` to verify that the data is the same.
+  `:compare_data` and `:smart` behaviors will change slightly based on
+  if you have the array plugin enabled. By default, they compare a
+  single element of what is being pointed to. So if you have a pointer
+  to a struct called ORGAN_T, it will compare one ORGAN_T (whatever that
+  is).
+
+
+Compiled Options:
+-----------------
+
+A number of #defines also exist for customizing the cmock experience. 
+
+CMOCK_MEM_STATIC or CMOCK_MEM_DYNAMIC 
+
+Define one of these to determine if you want to dynamically add 
+memory during tests as required from the heap. If static, you 
+can control the total footprint of Cmock. If dynamic, you will 
+need to make sure you make some heap space available for Cmock. 
+
+CMOCK_MEM_SIZE 
+
+In static mode this is the total amount of memory you are allocating 
+to Cmock. In Dynamic mode this is the size of each chunk allocated 
+at once (larger numbers grab more memory but require less mallocs). 
+
+CMOCK_MEM_ALIGN 
+
+The way to align your data to. Not everything is as flexible as 
+a PC, as most embedded designers know. This defaults to 2, meaning 
+align to the closest 2^2 -> 4 bytes (32 bits). You can turn off alignment 
+by setting 0, force alignment to the closest uint16 with 1 or even 
+to the closest uint64 with 3. 
+
+CMOCK_MEM_PTR_AS_INT 
+
+This is used internally to hold pointers... it needs to be big 
+enough. On most processors a pointer is the same as an unsigned 
+long... but maybe that's not true for yours? 
+
+CMOCK_MEM_INDEX_TYPE 
+
+This needs to be something big enough to point anywhere in Cmock's 
+memory space... usually it's an unsigned int. 
+