Formatiere den Quellcode mit clang-format

4 files changed, 363 insertions, 312 deletions

diff --git a/.clang-format b/.clang-format
new file mode 100644
index 0000000..b32bad6
--- /dev/null
+++ b/.clang-format
@@ -0,0 +1,45 @@
+---
+AccessModifierOffset: -4
+AlignConsecutiveAssignments: 'true'
+AlignConsecutiveDeclarations: 'true'
+AlignEscapedNewlines: Left
+AlignTrailingComments: 'true'
+AlwaysBreakAfterReturnType: TopLevelDefinitions
+BreakBeforeBraces: Stroustrup
+BreakConstructorInitializers: BeforeComma
+BreakInheritanceList: BeforeComma
+ColumnLimit: '0'
+CompactNamespaces: 'false'
+Cpp11BracedListStyle: 'false'
+FixNamespaceComments: 'true'
+IncludeBlocks: Regroup
+IncludeCategories:
+    - Regex: '^.*(precomp|pch|stdafx)'
+      Priority: -1
+    - Regex: '^<.*>'
+      Priority: 1
+    - Regex: '^".*"'
+      Priority: 2
+    - Regex: '.*'
+      Priority: 3
+IndentCaseLabels: 'false'
+IndentPPDirectives: AfterHash
+IndentWidth: '4'
+IndentWrappedFunctionNames: 'false'
+KeepEmptyLinesAtTheStartOfBlocks: 'false'
+PointerAlignment: Right
+SortIncludes: 'true'
+SpaceAfterCStyleCast: 'true'
+SpaceAfterTemplateKeyword: 'false'
+SpaceBeforeAssignmentOperators: 'true'
+SpaceBeforeParens: ControlStatements
+SpaceBeforeRangeBasedForLoopColon: 'false'
+SpaceInEmptyParentheses: 'false'
+SpacesInAngles: 'false'
+SpacesInCStyleCastParentheses: 'false'
+SpacesInConditionalStatement: 'true'
+SpacesInParentheses: 'false'
+Standard: Auto
+TabWidth: '4'
+UseTab: ForIndentation
+...
diff --git a/csv-test.c b/csv-test.c
index 8fbcf42..238bf74 100644
--- a/csv-test.c
+++ b/csv-test.c
@@ -1,19 +1,19 @@
 #undef NDEBUG
 
+#include <assert.h>
+#include <setjmp.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
-#include <assert.h>
-#include <setjmp.h>
 
 #include "csv.h"
 
-#define FMEMOPEN(f, data) \
-        f = fmemopen(data, sizeof(data)-1, "r"); \
+#define FMEMOPEN(f, data)                      \
+        f = fmemopen(data, sizeof(data) - 1, "r"); \
         assert(f != NULL)
 
 #define FMEMCLOSE(f) \
-        fclose(f); \
+        fclose(f);       \
         f = NULL
 
 void
@@ -21,13 +21,13 @@ test_empty_object(void)
 {
         {
                 csv_t csv = { 0 };
-                assert( csv_nfields(&csv) == 0 );
+                assert(csv_nfields(&csv) == 0);
         }
 
         {
                 csv_t csv;
                 csv_init(&csv);
-                assert( csv_nfields(&csv) == 0 );
+                assert(csv_nfields(&csv) == 0);
         }
 }
 
@@ -42,19 +42,19 @@ test_line_endings1(void)
 
         FMEMOPEN(f, data);
 
-        assert( csv_read(&csv, f) == 3 );
-        assert( csv_nfields(&csv) == 3 ),
-        assert( strcmp(csv_field(&csv, 0), "A") == 0 );
-        assert( strcmp(csv_field(&csv, 1), "B") == 0 );
-        assert( strcmp(csv_field(&csv, 2), "C") == 0 );
+        assert(csv_read(&csv, f) == 3);
+        assert(csv_nfields(&csv) == 3);
+        assert(strcmp(csv_field(&csv, 0), "A") == 0);
+        assert(strcmp(csv_field(&csv, 1), "B") == 0);
+        assert(strcmp(csv_field(&csv, 2), "C") == 0);
 
-        assert( csv_read(&csv, f) == 3 );
-        assert( csv_nfields(&csv) == 3 ),
-        assert( strcmp(csv_field(&csv, 0), "D") == 0 );
-        assert( strcmp(csv_field(&csv, 1), "E") == 0 );
-        assert( strcmp(csv_field(&csv, 2), "F") == 0 );
+        assert(csv_read(&csv, f) == 3);
+        assert(csv_nfields(&csv) == 3);
+        assert(strcmp(csv_field(&csv, 0), "D") == 0);
+        assert(strcmp(csv_field(&csv, 1), "E") == 0);
+        assert(strcmp(csv_field(&csv, 2), "F") == 0);
 
-        assert( csv_read(&csv, f) == EOF );
+        assert(csv_read(&csv, f) == EOF);
 
         FMEMCLOSE(f);
 }
@@ -70,19 +70,19 @@ test_line_endings2(void)
 
         FMEMOPEN(f, data);
 
-        assert( csv_read(&csv, f) == 3 );
-        assert( csv_nfields(&csv) == 3 ),
-        assert( strcmp(csv_field(&csv, 0), "A") == 0 );
-        assert( strcmp(csv_field(&csv, 1), "B") == 0 );
-        assert( strcmp(csv_field(&csv, 2), "C") == 0 );
+        assert(csv_read(&csv, f) == 3);
+        assert(csv_nfields(&csv) == 3);
+        assert(strcmp(csv_field(&csv, 0), "A") == 0);
+        assert(strcmp(csv_field(&csv, 1), "B") == 0);
+        assert(strcmp(csv_field(&csv, 2), "C") == 0);
 
-        assert( csv_read(&csv, f) == 3 );
-        assert( csv_nfields(&csv) == 3 ),
-        assert( strcmp(csv_field(&csv, 0), "D") == 0 );
-        assert( strcmp(csv_field(&csv, 1), "E") == 0 );
-        assert( strcmp(csv_field(&csv, 2), "F") == 0 );
+        assert(csv_read(&csv, f) == 3);
+        assert(csv_nfields(&csv) == 3);
+        assert(strcmp(csv_field(&csv, 0), "D") == 0);
+        assert(strcmp(csv_field(&csv, 1), "E") == 0);
+        assert(strcmp(csv_field(&csv, 2), "F") == 0);
 
-        assert( csv_read(&csv, f) == EOF );
+        assert(csv_read(&csv, f) == EOF);
 
         FMEMCLOSE(f);
 }
@@ -95,143 +95,143 @@ test_empty_fields(void)
 
         char data[] = "\n"
                       "\r"
-                                  "\r\n"
-                                  "\"\"\n"
-                                  "\"\"\r"
-                                  "\"\"\r\n"
-                                  ",\n"
-                                  ",\r"
-                                  ",\r\n"
-                                  "\"\",\"\"\n"
-                                  "\"\",\"\"\r"
-                                  "\"\",\"\"\r\n"
-                                  ",,\n"
-                                  ",,\r"
-                                  ",,\r\n"
-                                  "\"\",\"\",\n"
-                                  "\"\",\"\",\r"
-                                  "\"\",\"\",\r\n"
-                                  ",,";
+                      "\r\n"
+                      "\"\"\n"
+                      "\"\"\r"
+                      "\"\"\r\n"
+                      ",\n"
+                      ",\r"
+                      ",\r\n"
+                      "\"\",\"\"\n"
+                      "\"\",\"\"\r"
+                      "\"\",\"\"\r\n"
+                      ",,\n"
+                      ",,\r"
+                      ",,\r\n"
+                      "\"\",\"\",\n"
+                      "\"\",\"\",\r"
+                      "\"\",\"\",\r\n"
+                      ",,";
 
         FMEMOPEN(f, data);
 
         // Line 1
-        assert( csv_read(&csv, f) == 1 );
-        assert( csv_nfields(&csv) == 1 );
-        assert( strcmp(csv_field(&csv, 0), "") == 0 );
+        assert(csv_read(&csv, f) == 1);
+        assert(csv_nfields(&csv) == 1);
+        assert(strcmp(csv_field(&csv, 0), "") == 0);
 
         // Line 2
-        assert( csv_read(&csv, f) == 1 );
-        assert( csv_nfields(&csv) == 1 );
-        assert( strcmp(csv_field(&csv, 0), "") == 0 );
+        assert(csv_read(&csv, f) == 1);
+        assert(csv_nfields(&csv) == 1);
+        assert(strcmp(csv_field(&csv, 0), "") == 0);
 
         // Line 3
-        assert( csv_read(&csv, f) == 1 );
-        assert( csv_nfields(&csv) == 1 );
-        assert( strcmp(csv_field(&csv, 0), "") == 0 );
+        assert(csv_read(&csv, f) == 1);
+        assert(csv_nfields(&csv) == 1);
+        assert(strcmp(csv_field(&csv, 0), "") == 0);
 
         // Line 4
-        assert( csv_read(&csv, f) == 1 );
-        assert( csv_nfields(&csv) == 1 );
-        assert( strcmp(csv_field(&csv, 0), "") == 0 );
+        assert(csv_read(&csv, f) == 1);
+        assert(csv_nfields(&csv) == 1);
+        assert(strcmp(csv_field(&csv, 0), "") == 0);
 
         // Line 5
-        assert( csv_read(&csv, f) == 1 );
-        assert( csv_nfields(&csv) == 1 );
-        assert( strcmp(csv_field(&csv, 0), "") == 0 );
+        assert(csv_read(&csv, f) == 1);
+        assert(csv_nfields(&csv) == 1);
+        assert(strcmp(csv_field(&csv, 0), "") == 0);
 
         // Line 6
-        assert( csv_read(&csv, f) == 1 );
-        assert( csv_nfields(&csv) == 1 );
-        assert( strcmp(csv_field(&csv, 0), "") == 0 );
+        assert(csv_read(&csv, f) == 1);
+        assert(csv_nfields(&csv) == 1);
+        assert(strcmp(csv_field(&csv, 0), "") == 0);
 
         // Line 7
-        assert( csv_read(&csv, f) == 2 );
-        assert( csv_nfields(&csv) == 2 );
-        assert( strcmp(csv_field(&csv, 0), "") == 0 );
-        assert( strcmp(csv_field(&csv, 1), "") == 0 );
+        assert(csv_read(&csv, f) == 2);
+        assert(csv_nfields(&csv) == 2);
+        assert(strcmp(csv_field(&csv, 0), "") == 0);
+        assert(strcmp(csv_field(&csv, 1), "") == 0);
 
         // Line 8
-        assert( csv_read(&csv, f) == 2 );
-        assert( csv_nfields(&csv) == 2 );
-        assert( strcmp(csv_field(&csv, 0), "") == 0 );
-        assert( strcmp(csv_field(&csv, 1), "") == 0 );
+        assert(csv_read(&csv, f) == 2);
+        assert(csv_nfields(&csv) == 2);
+        assert(strcmp(csv_field(&csv, 0), "") == 0);
+        assert(strcmp(csv_field(&csv, 1), "") == 0);
 
         // Line 9
-        assert( csv_read(&csv, f) == 2 );
-        assert( csv_nfields(&csv) == 2 );
-        assert( strcmp(csv_field(&csv, 0), "") == 0 );
-        assert( strcmp(csv_field(&csv, 1), "") == 0 );
+        assert(csv_read(&csv, f) == 2);
+        assert(csv_nfields(&csv) == 2);
+        assert(strcmp(csv_field(&csv, 0), "") == 0);
+        assert(strcmp(csv_field(&csv, 1), "") == 0);
 
         // Line 10
-        assert( csv_read(&csv, f) == 2 );
-        assert( csv_nfields(&csv) == 2 );
-        assert( strcmp(csv_field(&csv, 0), "") == 0 );
-        assert( strcmp(csv_field(&csv, 1), "") == 0 );
+        assert(csv_read(&csv, f) == 2);
+        assert(csv_nfields(&csv) == 2);
+        assert(strcmp(csv_field(&csv, 0), "") == 0);
+        assert(strcmp(csv_field(&csv, 1), "") == 0);
 
         // Line 11
-        assert( csv_read(&csv, f) == 2 );
-        assert( csv_nfields(&csv) == 2 );
-        assert( strcmp(csv_field(&csv, 0), "") == 0 );
-        assert( strcmp(csv_field(&csv, 1), "") == 0 );
+        assert(csv_read(&csv, f) == 2);
+        assert(csv_nfields(&csv) == 2);
+        assert(strcmp(csv_field(&csv, 0), "") == 0);
+        assert(strcmp(csv_field(&csv, 1), "") == 0);
 
         // Line 12
-        assert( csv_read(&csv, f) == 2 );
-        assert( csv_nfields(&csv) == 2 );
-        assert( strcmp(csv_field(&csv, 0), "") == 0 );
-        assert( strcmp(csv_field(&csv, 1), "") == 0 );
+        assert(csv_read(&csv, f) == 2);
+        assert(csv_nfields(&csv) == 2);
+        assert(strcmp(csv_field(&csv, 0), "") == 0);
+        assert(strcmp(csv_field(&csv, 1), "") == 0);
 
         // Line 13
-        assert( csv_read(&csv, f) == 3 );
-        assert( csv_nfields(&csv) == 3 );
-        assert( strcmp(csv_field(&csv, 0), "") == 0 );
-        assert( strcmp(csv_field(&csv, 1), "") == 0 );
-        assert( strcmp(csv_field(&csv, 2), "") == 0 );
+        assert(csv_read(&csv, f) == 3);
+        assert(csv_nfields(&csv) == 3);
+        assert(strcmp(csv_field(&csv, 0), "") == 0);
+        assert(strcmp(csv_field(&csv, 1), "") == 0);
+        assert(strcmp(csv_field(&csv, 2), "") == 0);
 
         // Line 14
-        assert( csv_read(&csv, f) == 3 );
-        assert( csv_nfields(&csv) == 3 );
-        assert( strcmp(csv_field(&csv, 0), "") == 0 );
-        assert( strcmp(csv_field(&csv, 1), "") == 0 );
-        assert( strcmp(csv_field(&csv, 2), "") == 0 );
+        assert(csv_read(&csv, f) == 3);
+        assert(csv_nfields(&csv) == 3);
+        assert(strcmp(csv_field(&csv, 0), "") == 0);
+        assert(strcmp(csv_field(&csv, 1), "") == 0);
+        assert(strcmp(csv_field(&csv, 2), "") == 0);
 
         // Line 15
-        assert( csv_read(&csv, f) == 3 );
-        assert( csv_nfields(&csv) == 3 );
-        assert( strcmp(csv_field(&csv, 0), "") == 0 );
-        assert( strcmp(csv_field(&csv, 1), "") == 0 );
-        assert( strcmp(csv_field(&csv, 2), "") == 0 );
+        assert(csv_read(&csv, f) == 3);
+        assert(csv_nfields(&csv) == 3);
+        assert(strcmp(csv_field(&csv, 0), "") == 0);
+        assert(strcmp(csv_field(&csv, 1), "") == 0);
+        assert(strcmp(csv_field(&csv, 2), "") == 0);
 
         // Line 16
-        assert( csv_read(&csv, f) == 3 );
-        assert( csv_nfields(&csv) == 3 );
-        assert( strcmp(csv_field(&csv, 0), "") == 0 );
-        assert( strcmp(csv_field(&csv, 1), "") == 0 );
-        assert( strcmp(csv_field(&csv, 2), "") == 0 );
+        assert(csv_read(&csv, f) == 3);
+        assert(csv_nfields(&csv) == 3);
+        assert(strcmp(csv_field(&csv, 0), "") == 0);
+        assert(strcmp(csv_field(&csv, 1), "") == 0);
+        assert(strcmp(csv_field(&csv, 2), "") == 0);
 
         // Line 17
-        assert( csv_read(&csv, f) == 3 );
-        assert( csv_nfields(&csv) == 3 );
-        assert( strcmp(csv_field(&csv, 0), "") == 0 );
-        assert( strcmp(csv_field(&csv, 1), "") == 0 );
-        assert( strcmp(csv_field(&csv, 2), "") == 0 );
+        assert(csv_read(&csv, f) == 3);
+        assert(csv_nfields(&csv) == 3);
+        assert(strcmp(csv_field(&csv, 0), "") == 0);
+        assert(strcmp(csv_field(&csv, 1), "") == 0);
+        assert(strcmp(csv_field(&csv, 2), "") == 0);
 
         // Line 18
-        assert( csv_read(&csv, f) == 3 );
-        assert( csv_nfields(&csv) == 3 );
-        assert( strcmp(csv_field(&csv, 0), "") == 0 );
-        assert( strcmp(csv_field(&csv, 1), "") == 0 );
-        assert( strcmp(csv_field(&csv, 2), "") == 0 );
+        assert(csv_read(&csv, f) == 3);
+        assert(csv_nfields(&csv) == 3);
+        assert(strcmp(csv_field(&csv, 0), "") == 0);
+        assert(strcmp(csv_field(&csv, 1), "") == 0);
+        assert(strcmp(csv_field(&csv, 2), "") == 0);
 
         // Line 19
-        assert( csv_read(&csv, f) == 3 );
-        assert( csv_nfields(&csv) == 3 );
-        assert( strcmp(csv_field(&csv, 0), "") == 0 );
-        assert( strcmp(csv_field(&csv, 1), "") == 0 );
-        assert( strcmp(csv_field(&csv, 2), "") == 0 );
+        assert(csv_read(&csv, f) == 3);
+        assert(csv_nfields(&csv) == 3);
+        assert(strcmp(csv_field(&csv, 0), "") == 0);
+        assert(strcmp(csv_field(&csv, 1), "") == 0);
+        assert(strcmp(csv_field(&csv, 2), "") == 0);
 
         // EOF
-        assert( csv_read(&csv, f) == EOF );
+        assert(csv_read(&csv, f) == EOF);
 
         FMEMCLOSE(f);
 }
@@ -244,143 +244,143 @@ test_simple_fields(void)
 
         char data[] = "A\n"
                       "A\r"
-                                  "A\r\n"
-                                  "\"A\"\n"
-                                  "\"A\"\r"
-                                  "\"A\"\r\n"
-                                  "A,B\n"
-                                  "A,B\r"
-                                  "A,B\r\n"
-                                  "\"A\",\"B\"\n"
-                                  "\"A\",\"B\"\r"
-                                  "\"A\",\"B\"\r\n"
-                                  "A,B,C\n"
-                                  "A,B,C\r"
-                                  "A,B,C\r\n"
-                                  "\"A\",\"B\",C\n"
-                                  "\"A\",\"B\",C\r"
-                                  "\"A\",\"B\",C\r\n"
-                                  "A,B,C";
+                      "A\r\n"
+                      "\"A\"\n"
+                      "\"A\"\r"
+                      "\"A\"\r\n"
+                      "A,B\n"
+                      "A,B\r"
+                      "A,B\r\n"
+                      "\"A\",\"B\"\n"
+                      "\"A\",\"B\"\r"
+                      "\"A\",\"B\"\r\n"
+                      "A,B,C\n"
+                      "A,B,C\r"
+                      "A,B,C\r\n"
+                      "\"A\",\"B\",C\n"
+                      "\"A\",\"B\",C\r"
+                      "\"A\",\"B\",C\r\n"
+                      "A,B,C";
 
         FMEMOPEN(f, data);
 
         // Line 1
-        assert( csv_read(&csv, f) == 1 );
-        assert( csv_nfields(&csv) == 1 );
-        assert( strcmp(csv_field(&csv, 0), "A") == 0 );
+        assert(csv_read(&csv, f) == 1);
+        assert(csv_nfields(&csv) == 1);
+        assert(strcmp(csv_field(&csv, 0), "A") == 0);
 
         // Line 2
-        assert( csv_read(&csv, f) == 1 );
-        assert( csv_nfields(&csv) == 1 );
-        assert( strcmp(csv_field(&csv, 0), "A") == 0 );
+        assert(csv_read(&csv, f) == 1);
+        assert(csv_nfields(&csv) == 1);
+        assert(strcmp(csv_field(&csv, 0), "A") == 0);
 
         // Line 3
-        assert( csv_read(&csv, f) == 1 );
-        assert( csv_nfields(&csv) == 1 );
-        assert( strcmp(csv_field(&csv, 0), "A") == 0 );
+        assert(csv_read(&csv, f) == 1);
+        assert(csv_nfields(&csv) == 1);
+        assert(strcmp(csv_field(&csv, 0), "A") == 0);
 
         // Line 4
-        assert( csv_read(&csv, f) == 1 );
-        assert( csv_nfields(&csv) == 1 );
-        assert( strcmp(csv_field(&csv, 0), "A") == 0 );
+        assert(csv_read(&csv, f) == 1);
+        assert(csv_nfields(&csv) == 1);
+        assert(strcmp(csv_field(&csv, 0), "A") == 0);
 
         // Line 5
-        assert( csv_read(&csv, f) == 1 );
-        assert( csv_nfields(&csv) == 1 );
-        assert( strcmp(csv_field(&csv, 0), "A") == 0 );
+        assert(csv_read(&csv, f) == 1);
+        assert(csv_nfields(&csv) == 1);
+        assert(strcmp(csv_field(&csv, 0), "A") == 0);
 
         // Line 6
-        assert( csv_read(&csv, f) == 1 );
-        assert( csv_nfields(&csv) == 1 );
-        assert( strcmp(csv_field(&csv, 0), "A") == 0 );
+        assert(csv_read(&csv, f) == 1);
+        assert(csv_nfields(&csv) == 1);
+        assert(strcmp(csv_field(&csv, 0), "A") == 0);
 
         // Line 7
-        assert( csv_read(&csv, f) == 2 );
-        assert( csv_nfields(&csv) == 2 );
-        assert( strcmp(csv_field(&csv, 0), "A") == 0 );
-        assert( strcmp(csv_field(&csv, 1), "B") == 0 );
+        assert(csv_read(&csv, f) == 2);
+        assert(csv_nfields(&csv) == 2);
+        assert(strcmp(csv_field(&csv, 0), "A") == 0);
+        assert(strcmp(csv_field(&csv, 1), "B") == 0);
 
         // Line 8
-        assert( csv_read(&csv, f) == 2 );
-        assert( csv_nfields(&csv) == 2 );
-        assert( strcmp(csv_field(&csv, 0), "A") == 0 );
-        assert( strcmp(csv_field(&csv, 1), "B") == 0 );
+        assert(csv_read(&csv, f) == 2);
+        assert(csv_nfields(&csv) == 2);
+        assert(strcmp(csv_field(&csv, 0), "A") == 0);
+        assert(strcmp(csv_field(&csv, 1), "B") == 0);
 
         // Line 9
-        assert( csv_read(&csv, f) == 2 );
-        assert( csv_nfields(&csv) == 2 );
-        assert( strcmp(csv_field(&csv, 0), "A") == 0 );
-        assert( strcmp(csv_field(&csv, 1), "B") == 0 );
+        assert(csv_read(&csv, f) == 2);
+        assert(csv_nfields(&csv) == 2);
+        assert(strcmp(csv_field(&csv, 0), "A") == 0);
+        assert(strcmp(csv_field(&csv, 1), "B") == 0);
 
         // Line 10
-        assert( csv_read(&csv, f) == 2 );
-        assert( csv_nfields(&csv) == 2 );
-        assert( strcmp(csv_field(&csv, 0), "A") == 0 );
-        assert( strcmp(csv_field(&csv, 1), "B") == 0 );
+        assert(csv_read(&csv, f) == 2);
+        assert(csv_nfields(&csv) == 2);
+        assert(strcmp(csv_field(&csv, 0), "A") == 0);
+        assert(strcmp(csv_field(&csv, 1), "B") == 0);
 
         // Line 11
-        assert( csv_read(&csv, f) == 2 );
-        assert( csv_nfields(&csv) == 2 );
-        assert( strcmp(csv_field(&csv, 0), "A") == 0 );
-        assert( strcmp(csv_field(&csv, 1), "B") == 0 );
+        assert(csv_read(&csv, f) == 2);
+        assert(csv_nfields(&csv) == 2);
+        assert(strcmp(csv_field(&csv, 0), "A") == 0);
+        assert(strcmp(csv_field(&csv, 1), "B") == 0);
 
         // Line 12
-        assert( csv_read(&csv, f) == 2 );
-        assert( csv_nfields(&csv) == 2 );
-        assert( strcmp(csv_field(&csv, 0), "A") == 0 );
-        assert( strcmp(csv_field(&csv, 1), "B") == 0 );
+        assert(csv_read(&csv, f) == 2);
+        assert(csv_nfields(&csv) == 2);
+        assert(strcmp(csv_field(&csv, 0), "A") == 0);
+        assert(strcmp(csv_field(&csv, 1), "B") == 0);
 
         // Line 13
-        assert( csv_read(&csv, f) == 3 );
-        assert( csv_nfields(&csv) == 3 );
-        assert( strcmp(csv_field(&csv, 0), "A") == 0 );
-        assert( strcmp(csv_field(&csv, 1), "B") == 0 );
-        assert( strcmp(csv_field(&csv, 2), "C") == 0 );
+        assert(csv_read(&csv, f) == 3);
+        assert(csv_nfields(&csv) == 3);
+        assert(strcmp(csv_field(&csv, 0), "A") == 0);
+        assert(strcmp(csv_field(&csv, 1), "B") == 0);
+        assert(strcmp(csv_field(&csv, 2), "C") == 0);
 
         // Line 14
-        assert( csv_read(&csv, f) == 3 );
-        assert( csv_nfields(&csv) == 3 );
-        assert( strcmp(csv_field(&csv, 0), "A") == 0 );
-        assert( strcmp(csv_field(&csv, 1), "B") == 0 );
-        assert( strcmp(csv_field(&csv, 2), "C") == 0 );
+        assert(csv_read(&csv, f) == 3);
+        assert(csv_nfields(&csv) == 3);
+        assert(strcmp(csv_field(&csv, 0), "A") == 0);
+        assert(strcmp(csv_field(&csv, 1), "B") == 0);
+        assert(strcmp(csv_field(&csv, 2), "C") == 0);
 
         // Line 15
-        assert( csv_read(&csv, f) == 3 );
-        assert( csv_nfields(&csv) == 3 );
-        assert( strcmp(csv_field(&csv, 0), "A") == 0 );
-        assert( strcmp(csv_field(&csv, 1), "B") == 0 );
-        assert( strcmp(csv_field(&csv, 2), "C") == 0 );
+        assert(csv_read(&csv, f) == 3);
+        assert(csv_nfields(&csv) == 3);
+        assert(strcmp(csv_field(&csv, 0), "A") == 0);
+        assert(strcmp(csv_field(&csv, 1), "B") == 0);
+        assert(strcmp(csv_field(&csv, 2), "C") == 0);
 
         // Line 16
-        assert( csv_read(&csv, f) == 3 );
-        assert( csv_nfields(&csv) == 3 );
-        assert( strcmp(csv_field(&csv, 0), "A") == 0 );
-        assert( strcmp(csv_field(&csv, 1), "B") == 0 );
-        assert( strcmp(csv_field(&csv, 2), "C") == 0 );
+        assert(csv_read(&csv, f) == 3);
+        assert(csv_nfields(&csv) == 3);
+        assert(strcmp(csv_field(&csv, 0), "A") == 0);
+        assert(strcmp(csv_field(&csv, 1), "B") == 0);
+        assert(strcmp(csv_field(&csv, 2), "C") == 0);
 
         // Line 17
-        assert( csv_read(&csv, f) == 3 );
-        assert( csv_nfields(&csv) == 3 );
-        assert( strcmp(csv_field(&csv, 0), "A") == 0 );
-        assert( strcmp(csv_field(&csv, 1), "B") == 0 );
-        assert( strcmp(csv_field(&csv, 2), "C") == 0 );
+        assert(csv_read(&csv, f) == 3);
+        assert(csv_nfields(&csv) == 3);
+        assert(strcmp(csv_field(&csv, 0), "A") == 0);
+        assert(strcmp(csv_field(&csv, 1), "B") == 0);
+        assert(strcmp(csv_field(&csv, 2), "C") == 0);
 
         // Line 18
-        assert( csv_read(&csv, f) == 3 );
-        assert( csv_nfields(&csv) == 3 );
-        assert( strcmp(csv_field(&csv, 0), "A") == 0 );
-        assert( strcmp(csv_field(&csv, 1), "B") == 0 );
-        assert( strcmp(csv_field(&csv, 2), "C") == 0 );
+        assert(csv_read(&csv, f) == 3);
+        assert(csv_nfields(&csv) == 3);
+        assert(strcmp(csv_field(&csv, 0), "A") == 0);
+        assert(strcmp(csv_field(&csv, 1), "B") == 0);
+        assert(strcmp(csv_field(&csv, 2), "C") == 0);
 
         // Line 19
-        assert( csv_read(&csv, f) == 3 );
-        assert( csv_nfields(&csv) == 3 );
-        assert( strcmp(csv_field(&csv, 0), "A") == 0 );
-        assert( strcmp(csv_field(&csv, 1), "B") == 0 );
-        assert( strcmp(csv_field(&csv, 2), "C") == 0 );
+        assert(csv_read(&csv, f) == 3);
+        assert(csv_nfields(&csv) == 3);
+        assert(strcmp(csv_field(&csv, 0), "A") == 0);
+        assert(strcmp(csv_field(&csv, 1), "B") == 0);
+        assert(strcmp(csv_field(&csv, 2), "C") == 0);
 
         // EOF
-        assert( csv_read(&csv, f) == EOF );
+        assert(csv_read(&csv, f) == EOF);
 
         FMEMCLOSE(f);
 }
@@ -395,15 +395,15 @@ test_quoted_fields(void)
 
         FMEMOPEN(f, data);
 
-        assert( csv_read(&csv, f) == 5 );
-        assert( csv_nfields(&csv) == 5 ),
-        assert( strcmp(csv_field(&csv, 0), "foo \"baz\" bar") == 0 );
-        assert( strcmp(csv_field(&csv, 1), "foo \"\"baz\"\" bar") == 0 );
-        assert( strcmp(csv_field(&csv, 2), "foo \"baz\" bar") == 0 );
-        assert( strcmp(csv_field(&csv, 3), "foo \"baz\" bar") == 0 );
-        assert( strcmp(csv_field(&csv, 4), "foo \"baz\", bar") == 0 );
+        assert(csv_read(&csv, f) == 5);
+        assert(csv_nfields(&csv) == 5);
+        assert(strcmp(csv_field(&csv, 0), "foo \"baz\" bar") == 0);
+        assert(strcmp(csv_field(&csv, 1), "foo \"\"baz\"\" bar") == 0);
+        assert(strcmp(csv_field(&csv, 2), "foo \"baz\" bar") == 0);
+        assert(strcmp(csv_field(&csv, 3), "foo \"baz\" bar") == 0);
+        assert(strcmp(csv_field(&csv, 4), "foo \"baz\", bar") == 0);
 
-        assert( csv_read(&csv, f) == EOF );
+        assert(csv_read(&csv, f) == EOF);
 
         FMEMCLOSE(f);
 }
@@ -418,11 +418,11 @@ test_wrong_quoted_field(void)
 
         FMEMOPEN(f, data);
 
-        assert( csv_read(&csv, f) == 1 );
-        assert( csv_nfields(&csv) == 1 ),
-        assert( strcmp(csv_field(&csv, 0), "foo") == 0 );
+        assert(csv_read(&csv, f) == 1);
+        assert(csv_nfields(&csv) == 1);
+        assert(strcmp(csv_field(&csv, 0), "foo") == 0);
 
-        assert( csv_read(&csv, f) == EOF );
+        assert(csv_read(&csv, f) == EOF);
 
         FMEMCLOSE(f);
 }
@@ -436,26 +436,26 @@ cb_error(csv_err_t err, void *cb_arg)
 void
 test_out_of_range_error(void)
 {
-        jmp_buf env;
+        jmp_buf       env;
         csv_options_t csv_options = csv_default_options;
-        csv_options.cb_error = cb_error;
-        csv_options.cb_error_arg = &env;
+        csv_options.cb_error      = cb_error;
+        csv_options.cb_error_arg  = &env;
 
         csv_t csv;
         csv_init_opt(&csv, &csv_options);
 
         FILE *f;
-        char data[] = ",";
+        char  data[] = ",";
 
         FMEMOPEN(f, data);
 
         switch ( setjmp(env) ) {
         case CSV_ERR_OK:
-                assert( csv_read(&csv, f) == 2 );
-                assert( csv_nfields(&csv) == 2 );
+                assert(csv_read(&csv, f) == 2);
+                assert(csv_nfields(&csv) == 2);
 
                 // force an "out of range"-Exception!
-                assert( strcmp(csv_field(&csv, 2), "will fail") == 0 );
+                assert(strcmp(csv_field(&csv, 2), "will fail") == 0);
                 break;
 
         case CSV_ERR_OUT_OF_RANGE:
@@ -472,21 +472,21 @@ test_out_of_range_error(void)
 void
 test_read_error(void)
 {
-        jmp_buf env;
+        jmp_buf       env;
         csv_options_t csv_options = csv_default_options;
-        csv_options.cb_error = cb_error;
-        csv_options.cb_error_arg = &env;
+        csv_options.cb_error      = cb_error;
+        csv_options.cb_error_arg  = &env;
 
         csv_t csv;
         csv_init_opt(&csv, &csv_options);
 
         FILE *f = fopen("/dev/null", "r");
         assert(f != NULL);
-        fputc('T', f);  // Set Error-Flag!
+        fputc('T', f); // Set Error-Flag!
 
         switch ( setjmp(env) ) {
         case CSV_ERR_OK:
-                assert( csv_read(&csv, f) == EOF );
+                assert(csv_read(&csv, f) == EOF);
                 break;
 
         case CSV_ERR_IO_READ:
@@ -546,11 +546,11 @@ test_allocation_error1(void)
         jmp_buf env;
 
         csv_options_t csv_options = csv_default_options;
-        csv_options.cb_error = cb_error;
-        csv_options.cb_error_arg = &env;
-        csv_options.cb_allocate = my_allocate;
+        csv_options.cb_error      = cb_error;
+        csv_options.cb_error_arg  = &env;
+        csv_options.cb_allocate   = my_allocate;
         csv_options.cb_reallocate = my_reallocate;
-        csv_options.cb_free = my_free;
+        csv_options.cb_free       = my_free;
 
         csv_t csv;
         csv_init_opt(&csv, &csv_options);
@@ -563,7 +563,7 @@ test_allocation_error1(void)
 
         switch ( setjmp(env) ) {
         case CSV_ERR_OK:
-                assert( csv_read(&csv, f) == 20 );
+                assert(csv_read(&csv, f) == 20);
                 assert(!"this should not be happen!");
                 break;
 
diff --git a/csv.c b/csv.c
index 71c0e0f..2948911 100644
--- a/csv.c
+++ b/csv.c
@@ -1,29 +1,30 @@
+#include "csv.h"
+
+#include <assert.h>
 #include <stdio.h>
 #include <stdlib.h>
-#include <assert.h>
 #include <string.h>
-#include "csv.h"
 
 #ifndef CSV_DEFAULT_DELIMITER
-#define CSV_DEFAULT_DELIMITER '"'
+#       define CSV_DEFAULT_DELIMITER '"'
 #endif
 
 #ifndef CSV_DEFAULT_SEPARATOR
-#define CSV_DEFAULT_SEPARATOR ','
+#       define CSV_DEFAULT_SEPARATOR ','
 #endif
 
 #if defined(__GNUC__) || defined(__clang__)
-#define mul_overflow __builtin_mul_overflow
+#       define mul_overflow __builtin_mul_overflow
 #else
 static inline int
 mul_overflow(size_t a, size_t b, size_t *out)
 {
-    *out = a * b;
-    return ( a != 0 && (*out / a) != b );
+        *out = a * b;
+        return (a != 0 && (*out / a) != b);
 }
 #endif
 
-#define UNUSED(x) (void)(sizeof((x), 0))
+#define UNUSED(x) (void) (sizeof((x), 0))
 
 // === CSV-MEMORY Interface ===
 
@@ -66,16 +67,16 @@ csv_mem_free(void *ptr, size_t n, size_t sz, void *cb_arg)
 const csv_options_t csv_default_options = {
         .field_delimiter = CSV_DEFAULT_DELIMITER,
         .field_separator = CSV_DEFAULT_SEPARATOR,
-        .cb_error = NULL,
-        .cb_allocate = csv_mem_allocate,
-        .cb_reallocate = csv_mem_reallocate,
-        .cb_free = csv_mem_free
+        .cb_error        = NULL,
+        .cb_allocate     = csv_mem_allocate,
+        .cb_reallocate   = csv_mem_reallocate,
+        .cb_free         = csv_mem_free
 };
 
 // === CSV-ERROR Interface ===
 
 static void
-csv_fatal_error(csv_err_t csv_err, const csv_options_t * const csv_options)
+csv_fatal_error(csv_err_t csv_err, const csv_options_t *const csv_options)
 {
         if ( csv_options->cb_error != NULL ) {
                 (*csv_options->cb_error)(csv_err, csv_options->cb_error_arg);
@@ -109,27 +110,27 @@ csv_string_empty(csv_string_t *csv_string)
 {
         assert(csv_string != NULL);
 
-        return ( csv_string->pos == 0 ) ? 1 : 0;
+        return (csv_string->pos == 0) ? 1 : 0;
 }
 
 static inline void
-csv_string_append(csv_string_t *csv_string, char ch, const csv_options_t * const csv_options)
+csv_string_append(csv_string_t *csv_string, char ch, const csv_options_t *const csv_options)
 {
         assert(csv_string != NULL);
         assert(csv_options != NULL);
 
         static const int INITIAL_CAP = 16;
 
-        if ( csv_string->pos == csv_string->cap ) {  // grow if needed
-                if ( csv_string->str == NULL ) {         // first call?
+        if ( csv_string->pos == csv_string->cap ) { // grow if needed
+                if ( csv_string->str == NULL ) {        // first call?
                         if ( (csv_string->str = csv_options->cb_allocate(INITIAL_CAP, 1, csv_options->cb_memory_arg)) == NULL ) {
                                 csv_fatal_error(CSV_ERR_OUT_OF_MEMORY, csv_options);
                                 return;
                         }
                         csv_string->cap = INITIAL_CAP;
                 }
-                else {                                     // subsequent call
-                        int cap = (csv_string->cap * 3) / 2;   // *= 1.5
+                else {                                     // subsequent call
+                        int   cap = (csv_string->cap * 3) / 2; // *= 1.5
                         char *str = csv_options->cb_reallocate(csv_string->str, cap, 1, csv_options->cb_memory_arg);
                         if ( str == NULL ) {
                                 csv_fatal_error(CSV_ERR_OUT_OF_MEMORY, csv_options);
@@ -140,11 +141,11 @@ csv_string_append(csv_string_t *csv_string, char ch, const csv_options_t * const
                 }
         }
 
-        csv_string->str[csv_string->pos++] = ch;       // append char
+        csv_string->str[csv_string->pos++] = ch; // append char
 }
 
 static inline void
-csv_string_free(csv_string_t *csv_string, const csv_options_t * const csv_options)
+csv_string_free(csv_string_t *csv_string, const csv_options_t *const csv_options)
 {
         assert(csv_string != NULL);
         assert(csv_options != NULL);
@@ -163,8 +164,8 @@ csv_field_init(csv_field_t *csv_field)
         assert(csv_field != NULL);
 
         csv_field->fields = NULL;
-        csv_field->cap = 0;
-        csv_field->pos = 0;
+        csv_field->cap    = 0;
+        csv_field->pos    = 0;
 }
 
 static inline void
@@ -176,30 +177,30 @@ csv_field_reset(csv_field_t *csv_field)
 }
 
 static inline void
-csv_field_append(csv_field_t *csv_field, int idx, const csv_options_t * const csv_options)
+csv_field_append(csv_field_t *csv_field, int idx, const csv_options_t *const csv_options)
 {
         assert(csv_field != NULL);
         assert(csv_options != NULL);
 
         static const size_t INITIAL_CAP = 16;
 
-        if ( csv_field->pos == csv_field->cap ) {    // grow if needed
-                if ( csv_field->fields == NULL ) {       // first call
+        if ( csv_field->pos == csv_field->cap ) { // grow if needed
+                if ( csv_field->fields == NULL ) {    // first call
                         if ( (csv_field->fields = csv_options->cb_allocate(INITIAL_CAP, sizeof(csv_field->fields[0]), csv_options->cb_memory_arg)) == NULL ) {
                                 csv_fatal_error(CSV_ERR_OUT_OF_MEMORY, csv_options);
                                 return;
                         }
                         csv_field->cap = INITIAL_CAP;
                 }
-                else {                                   // subsequent call
-                        int cap = (csv_field->cap * 3) / 2;  // *= 1.5
+                else {                                      // subsequent call
+                        int  cap    = (csv_field->cap * 3) / 2; // *= 1.5
                         int *fields = csv_options->cb_reallocate(csv_field->fields, cap, sizeof(csv_field->fields[0]), csv_options->cb_memory_arg);
                         if ( fields == NULL ) {
                                 csv_fatal_error(CSV_ERR_OUT_OF_MEMORY, csv_options);
                                 return;
                         }
                         csv_field->fields = fields;
-                        csv_field->cap = cap;
+                        csv_field->cap    = cap;
                 }
         }
 
@@ -207,7 +208,7 @@ csv_field_append(csv_field_t *csv_field, int idx, const csv_options_t * const cs
 }
 
 static inline void
-csv_field_free(csv_field_t *csv_field, const csv_options_t * const csv_options)
+csv_field_free(csv_field_t *csv_field, const csv_options_t *const csv_options)
 {
         assert(csv_field != NULL);
         assert(csv_options != NULL);
@@ -228,7 +229,7 @@ csv_init(csv_t *csv)
 }
 
 void
-csv_init_opt(csv_t *csv, const csv_options_t * const csv_options)
+csv_init_opt(csv_t *csv, const csv_options_t *const csv_options)
 {
         assert(csv != NULL);
 
@@ -255,7 +256,7 @@ csv_cleanup(csv_t *csv)
 }
 
 int
-csv_nfields(const csv_t * const csv)
+csv_nfields(const csv_t *const csv)
 {
         assert(csv != NULL);
 
@@ -266,7 +267,7 @@ csv_nfields(const csv_t * const csv)
 }
 
 const char *
-csv_field(const csv_t * const csv, int idx)
+csv_field(const csv_t *const csv, int idx)
 {
         assert(csv != NULL);
         assert(idx >= 0 && idx < csv->csv_field.pos);
@@ -310,12 +311,12 @@ csv_read(csv_t *csv, FILE *in)
         };
 
         register const int DELIM = csv->csv_options->field_delimiter;
-        register const int SEP = csv->csv_options->field_separator;
+        register const int SEP   = csv->csv_options->field_separator;
 
         csv_string_reset(&csv->csv_string);
         csv_field_reset(&csv->csv_field);
 
-        for ( int state = STATE_START_FIELD; ; ) {
+        for ( int state = STATE_START_FIELD;; ) {
                 int ch;
 
                 switch ( state ) {
@@ -326,9 +327,9 @@ csv_read(csv_t *csv, FILE *in)
                         if ( ch == EOF ) {
                                 state = STATE_END_FILE;
                         }
-                        else if ( ch == '\r' ) {    // test for CR..
+                        else if ( ch == '\r' ) { // test for CR..
                                 ch = getc(in);
-                                if ( ch != '\n' ) {             // ..LF
+                                if ( ch != '\n' ) { // ..LF
                                         ungetc(ch, in);
                                 }
                                 state = STATE_END_LINE;
@@ -379,7 +380,7 @@ csv_read(csv_t *csv, FILE *in)
                                         }
                                         else {
                                                 csv_string_append(&csv->csv_string, DELIM, csv->csv_options);
-                                                ungetc(ch, in);    // we have read too far... Put the character back!
+                                                ungetc(ch, in); // we have read too far... Put the character back!
                                         }
                                 }
                                 else {
@@ -434,7 +435,7 @@ csv_read(csv_t *csv, FILE *in)
 
                         if ( csv_string_empty(&csv->csv_string) ) {
                                 csv_cleanup(csv);
-                                return EOF;      // EOF reached
+                                return EOF; // EOF reached
                         }
 
                         /*
@@ -458,18 +459,24 @@ const char *
 csv_err_str(csv_err_t csv_err)
 {
         switch ( csv_err ) {
-        case CSV_ERR_OK: return "no error";
-        case CSV_ERR_OUT_OF_MEMORY: return "out of memory";
-        case CSV_ERR_OUT_OF_RANGE: return "index out of range";
-        case CSV_ERR_IO_READ: return "read error";
-        case CSV_ERR_IO_WRITE: return "write error";
-        default: return "unknown error";
+        case CSV_ERR_OK:
+                return "no error";
+        case CSV_ERR_OUT_OF_MEMORY:
+                return "out of memory";
+        case CSV_ERR_OUT_OF_RANGE:
+                return "index out of range";
+        case CSV_ERR_IO_READ:
+                return "read error";
+        case CSV_ERR_IO_WRITE:
+                return "write error";
+        default:
+                return "unknown error";
         }
         // NOT REACHED
 }
 
 static void
-csv_write_field(FILE *out, const char *field, const csv_options_t * const csv_options)
+csv_write_field(FILE *out, const char *field, const csv_options_t *const csv_options)
 {
         assert(csv_options != NULL);
         assert(field != NULL);
@@ -499,7 +506,7 @@ csv_write_field(FILE *out, const char *field, const csv_options_t * const csv_op
 }
 
 void
-csv_write(FILE *out, const csv_t * const csv)
+csv_write(FILE *out, const csv_t *const csv)
 {
         assert(out != NULL);
         assert(csv != NULL);
@@ -510,8 +517,8 @@ csv_write(FILE *out, const csv_t * const csv)
         register const int SEP = csv->csv_options->field_separator;
 
         if ( 0 < csv->csv_field.pos ) {
-                const char *str = csv->csv_string.str;
-                const int *field = csv->csv_field.fields;
+                const char *str   = csv->csv_string.str;
+                const int * field = csv->csv_field.fields;
 
                 csv_write_field(out, &str[*field++], csv->csv_options);
 
@@ -529,7 +536,7 @@ csv_write(FILE *out, const csv_t * const csv)
 }
 
 void
-csv_write_ex(FILE *out, int n, const char *fields[], const csv_options_t * csv_options)
+csv_write_ex(FILE *out, int n, const char *fields[], const csv_options_t *csv_options)
 {
         assert(out != NULL);
         assert(fields != NULL);
@@ -558,4 +565,3 @@ csv_write_ex(FILE *out, int n, const char *fields[], const csv_options_t * csv_o
                 csv_fatal_error(CSV_ERR_IO_WRITE, csv_options);
         }
 }
-
diff --git a/csv.h b/csv.h
index 5ee7695..8abeb18 100644
--- a/csv.h
+++ b/csv.h
@@ -1,14 +1,14 @@
 #pragma once
 
-#include <stdio.h>      /* FILE */
-#include <stddef.h>     /* size_t */
+#include <stddef.h> /* size_t */
+#include <stdio.h>  /* FILE */
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
 typedef enum {
-        CSV_ERR_OK            =  0,
+        CSV_ERR_OK            = 0,
         CSV_ERR_OUT_OF_MEMORY = -1,
         CSV_ERR_OUT_OF_RANGE  = -2,
         CSV_ERR_IO_READ       = -3,
@@ -32,23 +32,23 @@ extern const csv_options_t csv_default_options;
 
 typedef struct {
         char *str;
-        int cap, pos;
+        int   cap, pos;
 } csv_string_t;
 
 typedef struct {
         int *fields;
-        int cap, pos;
+        int  cap, pos;
 } csv_field_t;
 
 typedef struct {
         const csv_options_t *csv_options;
-        csv_string_t csv_string;
-        csv_field_t csv_field;
+        csv_string_t         csv_string;
+        csv_field_t          csv_field;
 } csv_t;
 
 /* initialization */
 void csv_init(csv_t *csv);
-void csv_init_opt(csv_t *csv, const csv_options_t * const csv_options);
+void csv_init_opt(csv_t *csv, const csv_options_t *const csv_options);
 
 /* cleanup after error */
 void csv_cleanup(csv_t *csv);
@@ -57,15 +57,15 @@ void csv_cleanup(csv_t *csv);
 int csv_read(csv_t *csv, FILE *in);
 
 /* field access */
-int csv_nfields(const csv_t * const csv);
-const char * csv_field(const csv_t * const csv, int idx);
+int         csv_nfields(const csv_t *const csv);
+const char *csv_field(const csv_t *const csv, int idx);
 
 /* write */
-void csv_write(FILE *out, const csv_t * const csv);
-void csv_write_ex(FILE *out, int n, const char *fields[], const csv_options_t * const csv_options);
+void csv_write(FILE *out, const csv_t *const csv);
+void csv_write_ex(FILE *out, int n, const char *fields[], const csv_options_t *const csv_options);
 
 /* error handling */
-const char * csv_err_str(csv_err_t csv_err);
+const char *csv_err_str(csv_err_t csv_err);
 
 #ifdef __cplusplus
 }