Added basic CSV Parser

include/dawn/dawn.h

@@ -33,6 +33,7 @@
 
 // File / Asset Management
 #include "file/asset.h"
+#include "file/csv.h"
 
 // Game Logic
 #include "game/game.h"

include/dawn/file/csv.h

@@ -0,0 +1,50 @@
+/**
+ * Copyright (c) 2021 Dominic Masters
+ * 
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#pragma once
+#include "../libs.h"
+#include "asset.h"
+
+#define CSV_BUFFER_SIZE 128
+#define CSV_BUFFER_ROW_SIZE 16
+
+/** Result of a CSV buffer operation. */
+typedef struct {
+  /** How many rows within the CSV */
+  int32_t rowCount;
+  /** Count of columns in the CSV, this is the longest row in the CSV.  */
+  int32_t columnCount;
+  /** How many cells within the CSV */
+  int32_t cellCount;
+} csvbufferresult_t;
+
+/** Callback to receive data for each cell in a CSV being buffered */
+typedef void csvbuffercallback_t(
+  assetbuffer_t *asset, void *user, int32_t row, int32_t column, char *data
+);
+
+/** Callback to receive buffer data for a CSV row */
+typedef void csvbufferrowcallback_t(
+  assetbuffer_t *asset, void *user, int32_t row,
+  char **columns, int32_t columnCount
+);
+
+/** Data used by the cell callback for when the row buffering is progressing */
+typedef struct {
+  /** Which row the current buffer is on */
+  int32_t row;
+  /** Count of columns (in the current row) */
+  int32_t columnCount;
+  /** Array of characters for the row */
+  char rowData[CSV_BUFFER_ROW_SIZE * CSV_BUFFER_SIZE];
+  /** Pointers to the start of each string within the row */
+  char *columns[CSV_BUFFER_ROW_SIZE];
+  /** Pointer to custom user data */
+  void *user;
+  /** Pointer to custom user callback */
+  csvbufferrowcallback_t *callback;
+} csvbufferrowdata_t;

src/file/csv.c

@@ -0,0 +1,140 @@
+/**
+ * Copyright (c) 2021 Dominic Masters
+ * 
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#include "csv.h"
+
+// void csvPopulate(assetbuffer_t *asset, csv_t *output) {
+
+// }
+
+csvbufferresult_t csvBuffer(assetbuffer_t *asset, csvbuffercallback_t *callback, void *user){
+  int32_t cellChar, read, i, currentColumnCount;
+  char temp[CSV_BUFFER_SIZE];
+  char cell[CSV_BUFFER_SIZE];
+  char c;
+  bool insideEncapsulation = false;
+  csvbufferresult_t result = {
+    .cellCount = 0,
+    .rowCount = 0,
+    .columnCount = 0
+  };
+
+  // Init the cell Char Index.
+  cellChar = 0;
+  currentColumnCount = 0;
+
+  // Begin buffering.
+  while(true) {
+    // Read n bytes
+    read = assetBufferRead(asset, temp, CSV_BUFFER_SIZE);
+
+    // Now read back those bytes.
+    for(i = 0; i < read; i++) {
+      c = temp[i];
+
+      // Characters we flat out ignore
+      if(c == '\r') continue;
+
+      // Handle quote marks.
+      if(c == '"') {
+        if(temp[i+1] == '"') {// "" means a single quote (double-escaped)
+          i++;
+          cell[cellChar++] = c;
+        } else if(insideEncapsulation) {
+          insideEncapsulation = false;
+        } else {
+          insideEncapsulation = true;
+        }
+
+        continue;
+      }
+      
+      // Is the start of a new cell/row?
+      if(c == '\0' || (!insideEncapsulation && (c == ',' || c == '\n'))) {
+        cell[cellChar] = '\0';// Terminate Cell string
+
+        // Fire off the callback
+        if(callback != NULL) {
+          callback(asset, user, result.rowCount, result.cellCount, cell);
+        }
+
+        // Prepare for next row/cell
+        currentColumnCount++;
+        result.columnCount = mathMax(currentColumnCount, result.columnCount);
+        if(c == '\n') {
+          result.rowCount++;
+          currentColumnCount = 0;
+        }
+        result.cellCount++;// Only count cells with
+        cellChar = 0;
+        continue;// Skip
+      }
+
+      // Add character to the cell.
+      cell[cellChar++] = c;
+    }
+
+    if(read < CSV_BUFFER_SIZE) break;
+  }
+
+  // If this is an empty row we don't count it, otherwise we do.
+  if(currentColumnCount != 0) result.rowCount++;
+
+  // Finish buffering.
+  assetBufferClose(asset);
+  return result;
+}
+
+void _csvBufferRowParserCallback(assetbuffer_t *asset, void *user, int32_t row, int32_t column, char *data) {
+  csvbufferrowdata_t *rowData = (csvbufferrowdata_t *)user;
+
+  // Now did we change rows?
+  if(row != rowData->row) {
+    // Yes we did, let's buffer the previous row.
+    rowData->row = row;// Update row, basically this forces 1 indexing.
+    if(rowData->callback != NULL) {
+      rowData->callback(
+        asset, rowData->user, rowData->row,
+        rowData->columns, rowData->columnCount 
+      );
+    }
+    rowData->columnCount = 0;
+  }
+
+  // Determine string info for the cell
+  int32_t length = strlen(data);
+  int32_t offset = (column * CSV_BUFFER_ROW_SIZE);
+
+  // Now copy that data to the buffer
+  arrayCopy(
+    sizeof(char), data, length + 1,
+    rowData->rowData + offset
+  );
+  rowData->columns[column] = rowData->rowData + offset;
+  rowData->columnCount++;
+}
+
+csvbufferresult_t csvBufferRow(assetbuffer_t *asset, csvbufferrowcallback_t *callback, void *user) { 
+  csvbufferrowdata_t data;
+  csvbufferresult_t result;
+
+  data.row = 0;
+  data.columnCount = 0;
+  data.user = user;
+  data.callback = callback;
+
+  // Perform a per-cell buffer and run the parser callback.
+  result = csvBuffer(asset, &_csvBufferRowParserCallback, &data);
+
+  // Because the buffer may not fire for the last row we handle it here.
+  if(data.columnCount > 0 && callback != NULL) {
+    data.row++;// Because .row is 0 indexed until the "next line", we increment
+    callback(asset, user, data.row, data.columns, data.columnCount);
+  }
+
+  return result;
+}

src/file/csv.h

@@ -0,0 +1,16 @@
+/**
+ * Copyright (c) 2021 Dominic Masters
+ * 
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#pragma once
+#include <dawn/dawn.h>
+#include "asset.h"
+#include "../util/array.h"
+
+csvbufferresult_t csvBuffer(assetbuffer_t *asset, csvbuffercallback_t *callback, void *user);
+
+void _csvBufferRowParserCallback(assetbuffer_t *asset, void *user, int32_t row, int32_t column, char *data);
+csvbufferresult_t csvBufferRow(assetbuffer_t *asset, csvbufferrowcallback_t *callback, void *user);

src/game/game.c

@@ -7,10 +7,24 @@
 
 #include "game.h"
 
+void bruhCallback(
+  assetbuffer_t *asset, void *user, int32_t row,
+  char **columns, int32_t columnCount
+) {
+  int32_t bruh;
+  for(int32_t i = 0; i < columnCount; i++) {
+    char *string = columns [i];
+    printf(string);
+  }
+}
+
 bool gameInit(game_t *game) {
   // Init the engine and the rendering pipeline
   engineInit(&game->engine, game);
 
+  assetbuffer_t *buffer = assetBufferOpen("locale/language/en-US.csv");
+  csvbufferresult_t result = csvBufferRow(buffer, &bruhCallback, NULL);
+
   // Send off to the game instance
   #if SETTING_GAME == SETTING_GAME_POKER
     return pokerGameInit(game);

src/game/game.h

@@ -7,7 +7,7 @@
 #include <dawn/dawn.h>
 #include "../engine/engine.h"
 
-#include "../locale/language.h"
+#include "../file/csv.h"
 
 #if SETTING_GAME == SETTING_GAME_POKER
   #include "poker/pokergame.h"