CMake build, fix build with CPP_COMPILING, bug fixes

.clang-format

@@ -0,0 +1,18 @@
+---
+BasedOnStyle: LLVM
+IndentWidth: 2
+---
+Language: Cpp
+UseTab: Never
+ColumnLimit: 100
+AlignAfterOpenBracket: true
+BreakBeforeBraces: Allman
+AllowShortFunctionsOnASingleLine: InlineOnly
+ReflowComments: false
+BinPackParameters: false
+AlignEscapedNewlines: Right
+PointerAlignment: Left
+AlignConsecutiveDeclarations: true
+AlignEscapedNewlines: true
+IndentCaseLabels: true
+...

fixtures/DecisionTableExample.c

@@ -1,74 +1,76 @@
-#include <stdlib.h>
-#include <string.h>
-#include <stdio.h>
-#include "SlimList.h"
 #include "Fixtures.h"
+#include "SlimList.h"
 #include "compatibility.h"
-
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
 
 typedef struct Division
 {
-	double numerator;
-	double denominator;
-	char result[32];
+  double numerator;
+  double denominator;
+  char   result[32];
 } Division;
 
 void* Division_Create(StatementExecutor* errorHandler, SlimList* args)
 {
-	Division* self = (Division*)malloc(sizeof(Division));
-	memset(self, 0, sizeof(Division));
-	return self;
+  Division* self = (Division*)malloc(sizeof(Division));
+  memset(self, 0, sizeof(Division));
+  return self;
 }
 
 void Division_Destroy(void* void_self)
 {
-	free(void_self);
+  free(void_self);
 }
 
-static const char* setNumerator(void* void_self, SlimList* args) {
-	Division* self = (Division*)void_self;
-	self->numerator = atof(SlimList_GetStringAt(args, 0));
-	return "";
+static const char* setNumerator(void* void_self, SlimList* args)
+{
+  Division* self = (Division*)void_self;
+  self->numerator = atof(SlimList_GetStringAt(args, 0));
+  return "";
 }
 
-static const char* setDenominator(void* void_self, SlimList* args) {
-	Division* self = (Division*)void_self;
-	self->denominator = atof(SlimList_GetStringAt(args, 0));
-	if (self->denominator == 0.0)
-		return SLIM_EXCEPTION("You shouldn't divide by zero now should ya?");
-	return "";
+static const char* setDenominator(void* void_self, SlimList* args)
+{
+  Division* self = (Division*)void_self;
+  self->denominator = atof(SlimList_GetStringAt(args, 0));
+  if (self->denominator == 0.0)
+    return SLIM_EXCEPTION("You shouldn't divide by zero now should ya?");
+  return "";
 }
 
-static const char* Quotient(void* void_self, SlimList* args) {
-	Division* self = (Division*)void_self;
-	double quotient = self->numerator / self->denominator;
-	snprintf(self->result, 32, "%g", quotient);
-	return self->result;
+static const char* Quotient(void* void_self, SlimList* args)
+{
+  Division* self = (Division*)void_self;
+  double    quotient = self->numerator / self->denominator;
+  snprintf(self->result, 32, "%g", quotient);
+  return self->result;
 }
 
 //These are optional.  If they aren't declared, they are ignored
-static const char* execute(void* void_self, SlimList* args) {
-    return "";
+static const char* execute(void* void_self, SlimList* args)
+{
+  return "";
 }
 
-static const char* reset(void* void_self, SlimList* args) {
-	Division* self = (Division*)void_self;
-    self->denominator = 0.0f;
-    self->numerator = 0.0f;
-    return "";
+static const char* reset(void* void_self, SlimList* args)
+{
+  Division* self = (Division*)void_self;
+  self->denominator = 0.0f;
+  self->numerator = 0.0f;
+  return "";
 }
-static const char* table(void* void_self, SlimList* args) {
-    return "";
+static const char* table(void* void_self, SlimList* args)
+{
+  return "";
 }
 
-
-
 SLIM_CREATE_FIXTURE(Division)
-	SLIM_FUNCTION(setNumerator)
-	SLIM_FUNCTION(setDenominator)
-	SLIM_FUNCTION(Quotient)
-	SLIM_FUNCTION(execute)
-	SLIM_FUNCTION(reset)
-	SLIM_FUNCTION(table)
+SLIM_FUNCTION(setNumerator)
+SLIM_FUNCTION(setDenominator)
+SLIM_FUNCTION(Quotient)
+SLIM_FUNCTION(execute)
+SLIM_FUNCTION(reset)
+SLIM_FUNCTION(table)
 SLIM_END
-

fixtures/ExceptionsExample.c

@@ -1,33 +1,34 @@
+#include "Fixtures.h"
+#include "SlimList.h"
+#include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
-#include <stdio.h>
-#include "SlimList.h"
-#include "Fixtures.h"
 
 typedef void ExceptionsExample;
 
 void* ExceptionsExample_Create(StatementExecutor* errorHandler, SlimList* args)
 {
-	if (SlimList_GetLength(args) < 1) {
-		SLIM_CONSTRUCTOR_ERROR(errorHandler, "One arg required");
-		return NULL;
-	}
+  if (SlimList_GetLength(args) < 1)
+  {
+    SLIM_CONSTRUCTOR_ERROR(errorHandler, "One arg required");
+    return NULL;
+  }
 
-	ExceptionsExample* self = (ExceptionsExample*)malloc(1);
-	memset(self, 0, 1);
-	return self;
+  ExceptionsExample* self = (ExceptionsExample*)malloc(1);
+  memset(self, 0, 1);
+  return self;
 }
 
 void ExceptionsExample_Destroy(void* void_self)
 {
-	free(void_self);
+  free(void_self);
 }
 
-static const char* setTrouble(void* void_self, SlimList* args) {
-	return SLIM_EXCEPTION("You stink");
+static const char* setTrouble(void* void_self, SlimList* args)
+{
+  return SLIM_EXCEPTION("You stink");
 }
 
-SLIM_CREATE_FIXTURE(ExceptionsExample) 
-	SLIM_FUNCTION(setTrouble)
+SLIM_CREATE_FIXTURE(ExceptionsExample)
+SLIM_FUNCTION(setTrouble)
 SLIM_END
-

fixtures/FixtureInCpp.cpp

@@ -1,72 +1,71 @@
-#include <stdlib.h>
-#include <string.h>
-#include <stdio.h>
-#include "SlimList.h"
 #include "Fixtures.h"
+#include "SlimList.h"
 #include "compatibility.h"
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
 
 class cMultiplication
 {
 public:
-	cMultiplication(){};
-	~cMultiplication(){};
-	double product()
-	{
-		return m1*m2;
-	}
-	double m1;
-	double m2;
-	char result[32];
+  cMultiplication(){};
+  ~cMultiplication(){};
+  double product() { return m1 * m2; }
+  double m1;
+  double m2;
+  char   result[32];
 };
 
 #ifndef CPP_COMPILING
 extern "C" {
 #endif
 typedef struct Multiplication
 {
-	cMultiplication multiplication;
-	char result[32];
+  cMultiplication multiplication;
+  char            result[32];
 } Multiplication;
 
 void* Multiplication_Create(StatementExecutor* errorHandler, SlimList* args)
 {
-	Multiplication* self = (Multiplication*)malloc(sizeof(Multiplication));
-	self->result[0] = 0;
+  Multiplication* self = (Multiplication*)malloc(sizeof(Multiplication));
+  self->result[0] = 0;
   // self->multiplication = new cMultiplication();
-	return self;
+  return self;
 }
 
 void Multiplication_Destroy(void* void_self)
 {
-	Multiplication* self = (Multiplication*)void_self;
+  Multiplication* self = (Multiplication*)void_self;
   // delete self->multiplication;
-	free(self);
+  free(self);
 }
 
-static const char* setMultiplicand1(void* void_self, SlimList* args) {
-	Multiplication* self = (Multiplication*)void_self;
-	self->multiplication.m1 = atof(SlimList_GetStringAt(args, 0));
-	return self->result;
+static const char* setMultiplicand1(void* void_self, SlimList* args)
+{
+  Multiplication* self = (Multiplication*)void_self;
+  self->multiplication.m1 = atof(SlimList_GetStringAt(args, 0));
+  return self->result;
 }
 
-static const char* setMultiplicand2(void* void_self, SlimList* args) {
-	Multiplication* self = (Multiplication*)void_self;
-	self->multiplication.m2 = atof(SlimList_GetStringAt(args, 0));
-	return self->result;
+static const char* setMultiplicand2(void* void_self, SlimList* args)
+{
+  Multiplication* self = (Multiplication*)void_self;
+  self->multiplication.m2 = atof(SlimList_GetStringAt(args, 0));
+  return self->result;
 }
 
-static const char* Product(void* void_self, SlimList* args) {
-	Multiplication* self = (Multiplication*)void_self;
-	double product = self->multiplication.product();
-	snprintf(self->result, 32, "%g", product);
-	return self->result;
+static const char* Product(void* void_self, SlimList* args)
+{
+  Multiplication* self = (Multiplication*)void_self;
+  double          product = self->multiplication.product();
+  snprintf(self->result, 32, "%g", product);
+  return self->result;
 }
 
-
 SLIM_CREATE_FIXTURE(Multiplication)
-	SLIM_FUNCTION(setMultiplicand1)
-	SLIM_FUNCTION(setMultiplicand2)
-	SLIM_FUNCTION(Product)
+SLIM_FUNCTION(setMultiplicand1)
+SLIM_FUNCTION(setMultiplicand2)
+SLIM_FUNCTION(Product)
 SLIM_END
 
 #ifndef CPP_COMPILING

fixtures/Fixtures.c

@@ -1,12 +1,11 @@
 #include "Fixtures.h"
 
 SLIM_FIXTURES
-	SLIM_FIXTURE(Division)
-	SLIM_FIXTURE(Count)
-	SLIM_FIXTURE(EmployeePayRecordsRow)
-	SLIM_FIXTURE(ExceptionsExample)
-	SLIM_FIXTURE(Multiplication)
-	SLIM_FIXTURE(Echo)
-	SLIM_FIXTURE(EchoLoudly)
+SLIM_FIXTURE(Division)
+SLIM_FIXTURE(Count)
+SLIM_FIXTURE(EmployeePayRecordsRow)
+SLIM_FIXTURE(ExceptionsExample)
+SLIM_FIXTURE(Multiplication)
+SLIM_FIXTURE(Echo)
+SLIM_FIXTURE(EchoLoudly)
 SLIM_END
-

fixtures/Main.c

@@ -1,34 +1,33 @@
 #include "Slim.h"
-#include "SocketServer.h"
 #include "SlimConnectionHandler.h"
+#include "SocketServer.h"
 #include "TcpComLink.h"
 #include <stdlib.h>
 #include <string.h>
 
-Slim * slim;
+Slim* slim;
 
 int connection_handler(int socket)
 {
-	int result = 0;
-	TcpComLink * comLink = TcpComLink_Create(socket);
+  int         result = 0;
+  TcpComLink* comLink = TcpComLink_Create(socket);
 
   result = Slim_HandleConnection(slim, (void*)comLink, &TcpComLink_send, &TcpComLink_recv);
 
-	TcpComLink_Destroy(comLink);
+  TcpComLink_Destroy(comLink);
 
-	return result;
+  return result;
 }
 
 int main(int ac, char** av)
 {
   slim = Slim_Create();
-	SocketServer* server = SocketServer_Create();
-	SocketServer_register_handler(server, &connection_handler);
+  SocketServer* server = SocketServer_Create();
+  SocketServer_register_handler(server, &connection_handler);
 
-	int result = SocketServer_Run(server, av[1]);
+  int result = SocketServer_Run(server, av[1]);
 
-	SocketServer_Destroy(server);
+  SocketServer_Destroy(server);
   Slim_Destroy(slim);
-	return result;
+  return result;
 }
-