acpc_dealer 2.1.3 → 2.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 908fe7324c280b21ad9c8ef23910772b67b96c33
-  data.tar.gz: 001d18938556bd455536bb2cadeab360e80439ac
+  metadata.gz: 6efdce0a35fe154dc42128ecbb0c0178d25ca739
+  data.tar.gz: 0575059959d08e372dcc0e8b071d5301f54a3a04
 SHA512:
-  metadata.gz: 90d7b38a414a69ee50e28e846896533d1da0f1f5d319d3395a6bee5028aea36bcebf946876a8ce7257e28311cc20d8bf281dda13224879b119fd6e8af6b8388a
-  data.tar.gz: 5574c30df5baa79a5fc380ef2f6a8dff28ca78a0980deb8ad170671167837ecd9ef9cbb551e2821b3232bb37a481c0e1aae3263fef19563beec99176322f735d
+  metadata.gz: 4879476724145fb209baab610e1b55e34e60455f6014b1e8224e942d4465a84ae4b9a457c62e99232407297284c24161a97e83442c177c27a3afd94174020c08
+  data.tar.gz: 7e7eb6a63b6dfed32a17da8ea70bf4d0df1ca3cf86550e45942a84f066e497f2393ad51b2c98c030e98158a22802a776badcfd552be4717e003cd14ed24021cf

data/lib/acpc_dealer.rb

@@ -1,5 +1,6 @@
 require 'hand_evaluator'
 require "acpc_dealer/dealer_runner"
+require 'date'
 
 module AcpcDealer
   VENDOR_DIRECTORY = File.expand_path('../../vendor', __FILE__)
@@ -41,4 +42,18 @@ module AcpcDealer
       super port_number, host_name
     end
   end
+
+  def self.game_def_label(number_of_players, betting_type_key)
+    "#{number_of_players}P-#{betting_type_key}"
+  end
+
+  def self.default_match_name(players, game_def, seed)
+    "#{players.join('-')}.#{game_def}.r#{seed}.#{date}"
+  end
+
+  private
+
+  def self.date
+    "#{Date.today.strftime('%b%-d_%Y').downcase}"
+  end
 end

data/lib/acpc_dealer/version.rb

@@ -1,3 +1,3 @@
 module AcpcDealer
-  VERSION = "2.1.3"
+  VERSION = "2.2.0"
 end

data/vendor/project_acpc_server/example_player.kuhn.limit.3p.sh

@@ -0,0 +1,2 @@
+#!/bin/bash
+./example_player kuhn.limit.3p.game $1 $2

data/vendor/project_acpc_server/game.c

@@ -1444,7 +1444,6 @@ static int printBoardCards( const Game *game, const State *state,
   return c;
 }
 
-
 static int readStateCommon( const char *string, const Game *game,
 			    State *state )
 {

data/vendor/project_acpc_server/kuhn_3p_equilibrium_player.sf1.sh

@@ -1,3 +1,3 @@
 #!/bin/bash
 THIS_DIR=$( cd "$( dirname "$0" )" && pwd )
-cd $THIS_DIR && ./kuhn_3p_equilibrium_player/kuhn_3p_equilibrium_player -n $1 -p $2 --c11 0.0 --b11 0.25 --b21 0.25 --b32 0.9375 --c33 0.0 --c34 1.0 -g kuhn.limit.3p.game
+cd $THIS_DIR && ./kuhn_3p_equilibrium_player/kuhn_3p_equilibrium_player -n $1 -p $2 --c11 0.0 --b11 0.25 --b21 0.25 --b32 0.9375 --c33 0.0 --c34 1.0 -g kuhn.limit.3p.game -r 237363252

data/vendor/project_acpc_server/kuhn_3p_equilibrium_player.sf2.sh

@@ -1,3 +1,3 @@
 #!/bin/bash
 THIS_DIR=$( cd "$( dirname "$0" )" && pwd )
-cd $THIS_DIR && ./kuhn_3p_equilibrium_player/kuhn_3p_equilibrium_player -n $1 -p $2 --c11 0.5 --b11 0.25 --b21 0.0 --b23 0.125 --b32 0.75 --c33 0.0 --c34 0.75 -g kuhn.limit.3p.game
+cd $THIS_DIR && ./kuhn_3p_equilibrium_player/kuhn_3p_equilibrium_player -n $1 -p $2 --c11 0.5 --b11 0.25 --b21 0.0 --b23 0.125 --b32 0.75 --c33 0.0 --c34 0.75 -g kuhn.limit.3p.game -r 237363252 

data/vendor/project_acpc_server/kuhn_3p_equilibrium_player.sf3.sh

@@ -1,3 +1,3 @@
 #!/bin/bash
 THIS_DIR=$( cd "$( dirname "$0" )" && pwd )
-cd $THIS_DIR && ./kuhn_3p_equilibrium_player/kuhn_3p_equilibrium_player -n $1 -p $2 --c11 0.33 --b11 0.166667 --b32 0.791667 --c33 0.0 --c34 0.75 -g kuhn.limit.3p.game
+cd $THIS_DIR && ./kuhn_3p_equilibrium_player/kuhn_3p_equilibrium_player -n $1 -p $2 --c11 0.33 --b11 0.166667 --b32 0.791667 --c33 0.0 --c34 0.75 -g kuhn.limit.3p.game -r 237363252

data/vendor/project_acpc_server/kuhn_3p_equilibrium_player/README.md

@@ -1,35 +1,35 @@
 Kuhn 3-Player Equilibrium Player
 =================================
 `kuhn_3p_equilibrium_player` is an ACPC compatible player that connects to the
-ACPC dealer and plays 3-player Kuhn poker with an equilibrium component 
-strategy specified by its arguments from one of those specified by 
-[*A Parameterized Family of Equilibrium Profiles for Three-Player Kuhn 
-Poker*](http://poker.cs.ualberta.ca/publications/2013-techreport-nl-size.pdf), 
-written by Duane Szafron, Richard Gibson, and Nathan Sturtevant, found in 
-*Proceedings of the Twelfth International Conference on Autonomous Agents and 
+ACPC dealer and plays 3-player Kuhn poker with an equilibrium component
+strategy specified by its arguments from one of those specified by
+[*A Parameterized Family of Equilibrium Profiles for Three-Player Kuhn
+Poker*](http://poker.cs.ualberta.ca/publications/2013-techreport-nl-size.pdf),
+written by Duane Szafron, Richard Gibson, and Nathan Sturtevant, found in
+*Proceedings of the Twelfth International Conference on Autonomous Agents and
 Multiagent Systems (AAMAS-13)* in May 2013.
- 
+
 Equilibrium sub-families
 --------------------------
-There are three sub-families of equilibria identified by Szafron, Gibson, and 
+There are three sub-families of equilibria identified by Szafron, Gibson, and
 Sturtevant, each defined by a different value of parameter `c11`. Depending on
 the sub-family, different parameters must necessarily be provided, except for
 `c11`, `b11`, `b32`, `c33`, and `c34`, which are always necessary. Please
-see 
+see
 [the paper](http://poker.cs.ualberta.ca/publications/2013-techreport-nl-size.pdf)
-for the domain of each paramter. 
+for the domain of each paramter.
 
 - `c11 = 0.0` sub-family: `b21` must also be provided.
 - `c11 = 1/2.0` sub-family: `b21` and `b23` must also be provided.
-- `0.0 < c11 < 1/2.0` sub-family: No futher parameters are necessary. 
+- `0.0 < c11 < 1/2.0` sub-family: No futher parameters are necessary.
 
 License
 -------
 MIT license (see `LICENCE`).
 
-Acknowledgements
+Acknowledgments
 ----------------
-This project includes software developed for 
-the CException Project, by Mark VanderVoord and other 
+This project includes software developed for
+the CException Project, by Mark VanderVoord and other
 contributors, as well as the Unity Project, by Mike Karlesky,
 Mark VanderVoord, and Greg Williams and other contributors.

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

@@ -19,17 +19,17 @@ DealerConnection new_dealer_connection()
   return this;
 }
 
-void connect_to_dealer(DealerConnection* this)
+void connect_to_dealer(DealerConnection* thisPtr)
 {
-  assert(this);
+  assert(thisPtr);
 
-  int sock = connectTo(this->host, this->port);
+  int sock = connectTo(thisPtr->host, thisPtr->port);
   if( sock < 0 ) {
     exit( EXIT_FAILURE );
   }
-  this->toServer = fdopen( sock, "w" );
-  this->fromServer = fdopen( sock, "r" );
-  if(!(this->toServer && this->fromServer)) {
+  thisPtr->toServer = fdopen( sock, "w" );
+  thisPtr->fromServer = fdopen( sock, "r" );
+  if(!(thisPtr->toServer && thisPtr->fromServer)) {
     fprintf( stderr, "ERROR: could not get socket streams\n" );
     exit( EXIT_FAILURE );
   }
@@ -37,7 +37,7 @@ void connect_to_dealer(DealerConnection* this)
   /* send version string to dealer */
   if(
       fprintf(
-          this->toServer,
+          thisPtr->toServer,
           "VERSION:%"PRIu32".%"PRIu32".%"PRIu32"\n",
           VERSION_MAJOR, VERSION_MINOR, VERSION_REVISION
       ) != 14
@@ -45,5 +45,5 @@ void connect_to_dealer(DealerConnection* this)
     fprintf( stderr, "ERROR: could not get send version to server\n" );
     exit(EXIT_FAILURE);
   }
-  fflush(this->toServer);
+  fflush(thisPtr->toServer);
 }

data/vendor/project_acpc_server/kuhn_3p_equilibrium_player/src/dealer_connection.h

@@ -17,6 +17,6 @@ typedef struct {
 } DealerConnection;
 
 DealerConnection new_dealer_connection();
-void connect_to_dealer(DealerConnection* this);
+void connect_to_dealer(DealerConnection* thisPtr);
 
 #endif

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

@@ -9,7 +9,7 @@ Copyright (C) 2013 by the Computer Poker Research Group, University of Alberta
 #include <math.h>
 #include <assert.h>
 
-#include "CException.h"
+#include <CException.h>
 void print_and_throw_error(const char const *message)
 {
   fprintf(stderr, "ERROR: %s", message);
@@ -211,7 +211,7 @@ static void check_params(Kuhn3pEquilibriumPlayer* kuhn_3p_e_player)
 
 static void action_probs_p0(
     uint8_t card_rank,
-    const State const* state,
+    const State* state,
     double* probs
 ) {
   assert(probs);
@@ -239,9 +239,9 @@ static void action_probs_p0(
 }
 
 static void action_probs_p1(
-    const double const* params,
+    const double* params,
     uint8_t card_rank,
-    const State const* state,
+    const State* state,
     double* probs
 ) {
   assert(params);
@@ -309,9 +309,9 @@ static void action_probs_p1(
 }
 
 static void action_probs_p2(
-    const double const* params,
+    const double* params,
     uint8_t card_rank,
-    const State const* state,
+    const State* state,
     double* probs
 )
 {
@@ -386,8 +386,8 @@ static void action_probs_p2(
 /* create any private space needed for future calls
    game_def is a private copy allocated by the dealer for the player's use */
 Kuhn3pEquilibriumPlayer new_kuhn_3p_equilibrium_player(
-    const Game const* game_def,
-    const double const* params,
+    const Game* game_def,
+    const double* params,
     uint32_t seed
 )
 {
@@ -461,7 +461,7 @@ Action action(
    This is an extra function, and does _NOT_ need to be implemented
    to be considered a valid player.h interface. */
 void action_probs(
-    const Kuhn3pEquilibriumPlayer const* player,
+    const Kuhn3pEquilibriumPlayer* player,
     MatchState view,
     double* probs
 )

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

@@ -5,9 +5,9 @@ Copyright (C) 2013 by the Computer Poker Research Group, University of Alberta
 #ifndef __KUHN_3P_EQUILIBRIUM_PLAYER_H__
 #define __KUHN_3P_EQUILIBRIUM_PLAYER_H__
 
-#include "game.h"
-#include "rng.h"
-#include "net.h"
+#include <game.h>
+#include <rng.h>
+#include <net.h>
 
 // Types ----------------
 typedef enum {
@@ -33,7 +33,7 @@ typedef struct {
 
 typedef enum{JACK_RANK = 9, QUEEN_RANK, KING_RANK, ACE_RANK} CardRank;
 
-typedef enum{A_POSITION = 0, B_POSITION, C_POSITION} PlayerPosition;
+typedef enum{A_POSITION = 0, B_POSITION, C_POSITION, NUM_PLAYERS} PlayerPosition;
 
 // Constants -------------
 #define KUHN_SUIT 3
@@ -41,6 +41,7 @@ typedef enum{A_POSITION = 0, B_POSITION, C_POSITION} PlayerPosition;
 #define QUEEN makeCard(QUEEN_RANK, KUHN_SUIT)
 #define KING makeCard(KING_RANK, KUHN_SUIT)
 #define ACE makeCard(ACE_RANK, KUHN_SUIT)
+#define NUM_CARDS 4
 
 #define KAPPA (1/24.0)
 
@@ -90,8 +91,8 @@ static const double C4[] = {1.0, 1.0, 1.0, 1.0};
 // Functions -----------------
 double beta(const Kuhn3pEquilibriumPlayer* kuhn_3p_e_player);
 Kuhn3pEquilibriumPlayer new_kuhn_3p_equilibrium_player(
-    const Game const* game_def,
-    const double const* params,
+    const Game* game_def,
+    const double* params,
     uint32_t seed
 );
 Action action(
@@ -99,7 +100,7 @@ Action action(
     MatchState view
 );
 void action_probs(
-    const Kuhn3pEquilibriumPlayer const* player,
+    const Kuhn3pEquilibriumPlayer* player,
     MatchState view,
     double* probs
 );

data/vendor/project_acpc_server/kuhn_3p_equilibrium_player/vendor/cexception/docs/license.txt

@@ -1,30 +1,30 @@
- Copyright (c) 2007 Mark VanderVoord
-
- 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 end-user documentation included with the redistribution, if 
- any, must include the following acknowledgment: "This product 
- includes software developed for the CEXCeption Project, by Mark 
- VanderVoord and other contributors", in the same place and form 
- as other third-party acknowledgments.  Alternately, this 
- acknowledgment may appear in the software itself, in the same 
- form and location as other such third-party acknowledgments.
- 
- 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
+ Copyright (c) 2007 Mark VanderVoord
+
+ 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 end-user documentation included with the redistribution, if 
+ any, must include the following acknowledgment: "This product 
+ includes software developed for the CEXCeption Project, by Mark 
+ VanderVoord and other contributors", in the same place and form 
+ as other third-party acknowledgments.  Alternately, this 
+ acknowledgment may appear in the software itself, in the same 
+ form and location as other such third-party acknowledgments.
+ 
+ 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/cexception/docs/readme.txt

@@ -1,242 +1,242 @@
-====================================================================
-CException
-====================================================================
-
-CException is a basic exception framework for C, suitable for use in
-embedded applications.  It provides an exception framework similar in
-use to C++, but with much less overhead.
-
-CException uses C standard library functions setjmp and longjmp to 
-operate.  As long as the target system has these two functions defined,
-this library should be useable with very little configuration.  It 
-even supports environments where multiple program flows are in use, 
-such as real-time operating systems.
-
-There are about a gabillion exception frameworks using a similar 
-setjmp/longjmp method out there... and there will probably be more 
-in the future. Unfortunately, when we started our last embedded 
-project, all those that existed either (a) did not support multiple 
-tasks (therefore multiple stacks) or (b) were way more complex than 
-we really wanted.  CException was born.
-
-Why use CException?
-
-0. It's ANSI C, and it beats passing error codes around.
-
-1. You want something simple... CException throws a single id. You can 
-   define those ID's to be whatever you like. You might even choose which 
-   type that number is for your project. But that's as far as it goes. 
-   We weren't interested in passing objects or structs or strings... 
-   just simple error codes.
-
-2. Performance... CException can be configured for single tasking or 
-   multitasking. In single tasking, there is very little overhead past 
-   the setjmp/longjmp calls (which are already fast). In multitasking, 
-   your only additional overhead is the time it takes you to determine 
-   a unique task id 0 - num_tasks. 
-
-For the latest version, go to http://cexception.sourceforge.net
-
---------------------------------------------------------------------
-CONTENTS OF THIS DOCUMENT
---------------------------------------------------------------------
-
-Usage
-Limitations
-API
-Configuration
-Testing
-License
-
---------------------------------------------------------------------
-Usage
---------------------------------------------------------------------
-
-Code that is to be protected are wrapped in Try { } Catch { } blocks.
-The code directly following the Try call is "protected", meaning that
-if any Throws occur, program control is directly transferred to the
-start of the Catch block.
-
-A numerical exception ID is included with Throw, and is made accessible
-from the Catch block.
-
-Throws can occur from within function calls (nested as deeply as you 
-like) or directly from within the function itself.
-
---------------------------------------------------------------------
-Limitations
---------------------------------------------------------------------
-
-This library was made to be as fast as possible, and provide basic
-exception handling.  It is not a full-blown exception library.  Because 
-of this, there are a few limitations that should be observed in order 
-to successfully utilize this library:
-
-1. Do not directly "return" from within a Try block, nor "goto" 
-   into or out of a Try block.  
-   
-   Why? 
-   
-   The "Try" macro allocates some local memory and alters a global 
-   pointer.  These are cleaned up at the top of the "Catch" macro. 
-   Gotos and returns would bypass some of these steps, resulting in
-   memory leaks or unpredictable behavior.
-   
-2. If (a) you change local (stack) variables within your Try block, 
-   AND (b) wish to make use of the updated values after an exception 
-   is thrown, those variables should be made volatile. Note that this 
-   is ONLY for locals and ONLY when you need access to them after a 
-   throw.
-   
-   Why?
-   
-   Compilers optimize.  There is no way to guarantee that the actual 
-   memory location was updated and not just a register unless the 
-   variable is marked volatile.
-
-3. Memory which is malloc'd or new'd is not automatically released
-   when an error is thrown.  This will sometimes be desirable, and
-   othertimes may not.  It will be the responsibility of the Catch
-   block to perform this kind of cleanup.
-   
-   Why?
-   
-   There's just no easy way to track malloc'd memory, etc., without
-   replacing or wrapping malloc calls or something like that.  This 
-   is a light framework, so these options were not desirable.
-   
---------------------------------------------------------------------
-API
---------------------------------------------------------------------
-
-Try
----
-
-Try is a macro which starts a protected block.  It MUST be followed by 
-a pair of braces or a single protected line (similar to an 'if'), 
-enclosing the data that is to be protected.  It MUST be followed by a 
-Catch block (don't worry, you'll get compiler errors to let you know if 
-you mess any of that up).
-
-Catch(e)
---------
-
-Catch is a macro which ends the Try block and starts the error handling 
-block. The catch block is called if and only if an exception was thrown 
-while within the Try block.  This error was thrown by a Throw call 
-somewhere within Try (or within a function called within Try, or a function
-called by a function called within Try, etc).
-
-The single parameter 'e' is filled with the error code which was thrown.
-This can be used for reporting, conditional cleanup, etc. (or you can just
-ignore it if you really want... people ignore return codes all the time, 
-right?).  'e' should be of type EXCEPTION_T;
-
-Throw(e)
---------
-
-The method of throwing an error.  Throws should only occur from within a
-protected (Try...Catch) block, though it may easily be nested many function
-calls deep without an impact on performance or functionality.  Throw takes 
-a single argument, which is an exception id which will be passed to Catch 
-as the reason for the error.
-
-If you wish to Rethrow an error, this can be done by calling Throw(e) with
-the error code you just caught.  It IS valid to throw from a catch block.
-
---------------------------------------------------------------------
-CONFIGURATION
---------------------------------------------------------------------
-
-CException is a mostly portable library.  It has one universal 
-dependency, and some macros which are required if working in a 
-multi-tasking environment.
-
-1. The standard C library setjmp must be available.  Since this is part
-   of the standard library, chances are good that you'll be fine.
-
-2. If working in a multitasking environment, methods for obtaining an 
-   index into an array of frames and to get the overall number of 
-   id's are required.  If the OS supports a method to retrieve Task 
-   ID's, and those Tasks are number 0, 1, 2... you are in an ideal 
-   situation.  Otherwise, a more creative mapping function may be 
-   required.  Note that this function is likely to be called twice 
-   for each protected block and once during a throw.  This is the 
-   only overhead in the system.
-   
-Exception.h
------------------
-By convention, most projects include Exception.h which defines any 
-further requirements, then calls CException.h to do the gruntwork.  All
-of these are optional.  You could directly include CException.h if
-you wanted and just use the defaults provided.
-
-EXCEPTION_T      - Set this to the type you want your exception id's 
-                   to be.  Defaults to 'unsigned int'.
-
-EXCEPTION_NONE   - Set this to a number which will never be an 
-                   exception id in your system.  Defaults to 0x5a5a5a5a.
-
-EXCEPTION_GET_ID - If in a multi-tasking environment, this should be 
-                   set to be a call to the function described in #2 above.
-                   Defaults to just return 0 all the time (good for 
-                   single tasking environments)
-                     
-EXCEPTION_NUM_ID - If in a multi-tasking environment, this should be set
-                   to the number of ID's required (usually the number of
-                   tasks in the system).  Defaults to 1 (for single
-                   tasking environments).
-
-CEXCEPTION_NO_CATCH_HANDLER(id) - This macro can be optionally specified.  
-                   It allows you to specify code to be called when a Throw 
-                   is made outside of Try...Catch protection.  Consider 
-                   this the emergency fallback plan for when something has 
-                   gone terribly wrong.
-
-You may also want to include any header files which will commonly be
-needed by the rest of your application where it uses exception handling 
-here.  For example, OS header files or exception codes would be useful.
-
---------------------------------------------------------------------
-TESTING
---------------------------------------------------------------------
-
-If you want to validate that CException works with your tools or that
-it works with your custom configuration, you may want to run the test
-suite.
-
-The test suite included makes use of the Unity Test Framework.  It will
-require a native C compiler. The example makefile uses MinGW's gcc.  
-Modify the makefile to include the proper paths to tools, then run 'make'
-to compile and run the test application.  
-
-C_COMPILER - The C compiler to use to perform the tests
-C_LIBS - The path to the C libraries (including setjmp) 
-UNITY_DIR - The path to the Unity framework (required to run tests)
-            (get it at http://unity.sourceforge.net)
-
---------------------------------------------------------------------
-LICENSE
---------------------------------------------------------------------
-
-This software is licensed under the MIT License
-
-Copyright (c) 2007-2012 Mark VanderVoord
-
-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.
+====================================================================
+CException
+====================================================================
+
+CException is a basic exception framework for C, suitable for use in
+embedded applications.  It provides an exception framework similar in
+use to C++, but with much less overhead.
+
+CException uses C standard library functions setjmp and longjmp to 
+operate.  As long as the target system has these two functions defined,
+this library should be useable with very little configuration.  It 
+even supports environments where multiple program flows are in use, 
+such as real-time operating systems.
+
+There are about a gabillion exception frameworks using a similar 
+setjmp/longjmp method out there... and there will probably be more 
+in the future. Unfortunately, when we started our last embedded 
+project, all those that existed either (a) did not support multiple 
+tasks (therefore multiple stacks) or (b) were way more complex than 
+we really wanted.  CException was born.
+
+Why use CException?
+
+0. It's ANSI C, and it beats passing error codes around.
+
+1. You want something simple... CException throws a single id. You can 
+   define those ID's to be whatever you like. You might even choose which 
+   type that number is for your project. But that's as far as it goes. 
+   We weren't interested in passing objects or structs or strings... 
+   just simple error codes.
+
+2. Performance... CException can be configured for single tasking or 
+   multitasking. In single tasking, there is very little overhead past 
+   the setjmp/longjmp calls (which are already fast). In multitasking, 
+   your only additional overhead is the time it takes you to determine 
+   a unique task id 0 - num_tasks. 
+
+For the latest version, go to http://cexception.sourceforge.net
+
+--------------------------------------------------------------------
+CONTENTS OF THIS DOCUMENT
+--------------------------------------------------------------------
+
+Usage
+Limitations
+API
+Configuration
+Testing
+License
+
+--------------------------------------------------------------------
+Usage
+--------------------------------------------------------------------
+
+Code that is to be protected are wrapped in Try { } Catch { } blocks.
+The code directly following the Try call is "protected", meaning that
+if any Throws occur, program control is directly transferred to the
+start of the Catch block.
+
+A numerical exception ID is included with Throw, and is made accessible
+from the Catch block.
+
+Throws can occur from within function calls (nested as deeply as you 
+like) or directly from within the function itself.
+
+--------------------------------------------------------------------
+Limitations
+--------------------------------------------------------------------
+
+This library was made to be as fast as possible, and provide basic
+exception handling.  It is not a full-blown exception library.  Because 
+of this, there are a few limitations that should be observed in order 
+to successfully utilize this library:
+
+1. Do not directly "return" from within a Try block, nor "goto" 
+   into or out of a Try block.  
+   
+   Why? 
+   
+   The "Try" macro allocates some local memory and alters a global 
+   pointer.  These are cleaned up at the top of the "Catch" macro. 
+   Gotos and returns would bypass some of these steps, resulting in
+   memory leaks or unpredictable behavior.
+   
+2. If (a) you change local (stack) variables within your Try block, 
+   AND (b) wish to make use of the updated values after an exception 
+   is thrown, those variables should be made volatile. Note that this 
+   is ONLY for locals and ONLY when you need access to them after a 
+   throw.
+   
+   Why?
+   
+   Compilers optimize.  There is no way to guarantee that the actual 
+   memory location was updated and not just a register unless the 
+   variable is marked volatile.
+
+3. Memory which is malloc'd or new'd is not automatically released
+   when an error is thrown.  This will sometimes be desirable, and
+   othertimes may not.  It will be the responsibility of the Catch
+   block to perform this kind of cleanup.
+   
+   Why?
+   
+   There's just no easy way to track malloc'd memory, etc., without
+   replacing or wrapping malloc calls or something like that.  This 
+   is a light framework, so these options were not desirable.
+   
+--------------------------------------------------------------------
+API
+--------------------------------------------------------------------
+
+Try
+---
+
+Try is a macro which starts a protected block.  It MUST be followed by 
+a pair of braces or a single protected line (similar to an 'if'), 
+enclosing the data that is to be protected.  It MUST be followed by a 
+Catch block (don't worry, you'll get compiler errors to let you know if 
+you mess any of that up).
+
+Catch(e)
+--------
+
+Catch is a macro which ends the Try block and starts the error handling 
+block. The catch block is called if and only if an exception was thrown 
+while within the Try block.  This error was thrown by a Throw call 
+somewhere within Try (or within a function called within Try, or a function
+called by a function called within Try, etc).
+
+The single parameter 'e' is filled with the error code which was thrown.
+This can be used for reporting, conditional cleanup, etc. (or you can just
+ignore it if you really want... people ignore return codes all the time, 
+right?).  'e' should be of type EXCEPTION_T;
+
+Throw(e)
+--------
+
+The method of throwing an error.  Throws should only occur from within a
+protected (Try...Catch) block, though it may easily be nested many function
+calls deep without an impact on performance or functionality.  Throw takes 
+a single argument, which is an exception id which will be passed to Catch 
+as the reason for the error.
+
+If you wish to Rethrow an error, this can be done by calling Throw(e) with
+the error code you just caught.  It IS valid to throw from a catch block.
+
+--------------------------------------------------------------------
+CONFIGURATION
+--------------------------------------------------------------------
+
+CException is a mostly portable library.  It has one universal 
+dependency, and some macros which are required if working in a 
+multi-tasking environment.
+
+1. The standard C library setjmp must be available.  Since this is part
+   of the standard library, chances are good that you'll be fine.
+
+2. If working in a multitasking environment, methods for obtaining an 
+   index into an array of frames and to get the overall number of 
+   id's are required.  If the OS supports a method to retrieve Task 
+   ID's, and those Tasks are number 0, 1, 2... you are in an ideal 
+   situation.  Otherwise, a more creative mapping function may be 
+   required.  Note that this function is likely to be called twice 
+   for each protected block and once during a throw.  This is the 
+   only overhead in the system.
+   
+Exception.h
+-----------------
+By convention, most projects include Exception.h which defines any 
+further requirements, then calls CException.h to do the gruntwork.  All
+of these are optional.  You could directly include CException.h if
+you wanted and just use the defaults provided.
+
+EXCEPTION_T      - Set this to the type you want your exception id's 
+                   to be.  Defaults to 'unsigned int'.
+
+EXCEPTION_NONE   - Set this to a number which will never be an 
+                   exception id in your system.  Defaults to 0x5a5a5a5a.
+
+EXCEPTION_GET_ID - If in a multi-tasking environment, this should be 
+                   set to be a call to the function described in #2 above.
+                   Defaults to just return 0 all the time (good for 
+                   single tasking environments)
+                     
+EXCEPTION_NUM_ID - If in a multi-tasking environment, this should be set
+                   to the number of ID's required (usually the number of
+                   tasks in the system).  Defaults to 1 (for single
+                   tasking environments).
+
+CEXCEPTION_NO_CATCH_HANDLER(id) - This macro can be optionally specified.  
+                   It allows you to specify code to be called when a Throw 
+                   is made outside of Try...Catch protection.  Consider 
+                   this the emergency fallback plan for when something has 
+                   gone terribly wrong.
+
+You may also want to include any header files which will commonly be
+needed by the rest of your application where it uses exception handling 
+here.  For example, OS header files or exception codes would be useful.
+
+--------------------------------------------------------------------
+TESTING
+--------------------------------------------------------------------
+
+If you want to validate that CException works with your tools or that
+it works with your custom configuration, you may want to run the test
+suite.
+
+The test suite included makes use of the Unity Test Framework.  It will
+require a native C compiler. The example makefile uses MinGW's gcc.  
+Modify the makefile to include the proper paths to tools, then run 'make'
+to compile and run the test application.  
+
+C_COMPILER - The C compiler to use to perform the tests
+C_LIBS - The path to the C libraries (including setjmp) 
+UNITY_DIR - The path to the Unity framework (required to run tests)
+            (get it at http://unity.sourceforge.net)
+
+--------------------------------------------------------------------
+LICENSE
+--------------------------------------------------------------------
+
+This software is licensed under the MIT License
+
+Copyright (c) 2007-2012 Mark VanderVoord
+
+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.