Merge branch 'feat/c'

Author: ThePat02

.gitignore

@@ -0,0 +1 @@
+bin/

.vscode/c_cpp_properties.json

@@ -0,0 +1,16 @@
+{
+    "configurations": [
+        {
+            "name": "Linux",
+            "includePath": [
+                "${workspaceFolder}/**"
+            ],
+            "defines": [],
+            "compilerPath": "/usr/bin/clang",
+            "cStandard": "c17",
+            "cppStandard": "c++17",
+            "intelliSenseMode": "linux-clang-x64"
+        }
+    ],
+    "version": 4
+}

.vscode/settings.json

@@ -0,0 +1,6 @@
+{
+    "files.associations": {
+        "stdlib.h": "c",
+        "libquill.h": "c"
+    }
+}

Makefile

@@ -0,0 +1,38 @@
+.PHONY: all clean build test-c shared-lib
+
+# Default target
+all: build shared-lib
+
+# Build the binary
+build:
+	@echo "Building Go binary..."
+	@mkdir -p bin
+	go build -o bin/quill cmd/quill/main.go
+	@echo "Binary built: bin/quill"
+
+# Build the shared library
+shared-lib:
+	@echo "Building shared library..."
+	@mkdir -p bin
+	CGO_ENABLED=1 go build -buildmode=c-shared -o bin/libquill.so cmd/c/main.go
+	@echo "Shared library built: bin/libquill.so"
+	@echo "Header file: bin/libquill.h"
+
+# Clean build folder
+clean:
+	rm -rf bin
+	@echo "Cleaned build folder."
+
+# Test the C API
+test-c: shared-lib
+	@echo "Building C test..."
+	gcc -Wall -Wextra -std=c99 \
+		-I./bin \
+		-L./bin \
+		-o bin/test_quill \
+		examples/c/example.c \
+		-lquill \
+		-Wl,-rpath,$$PWD/bin
+	@echo "C test built: bin/test_quill"
+	@echo "Running C test..."
+	LD_LIBRARY_PATH=./bin ./bin/test_quill

cmd/c/main.go

@@ -0,0 +1,150 @@
+package main
+
+// #include <stdlib.h>
+// #include <stdio.h>
+import "C"
+import (
+	"quill/internal/jsonapi"
+	"sync"
+	"unsafe"
+)
+
+var (
+	interpreters = make(map[int]*jsonapi.QuillInterpreter)
+	nextID       = 1
+	mu           sync.Mutex
+)
+
+//export quill_new_interpreter
+func quill_new_interpreter(source *C.char) *C.char {
+	goSource := C.GoString(source)
+	interp, result := jsonapi.NewQuillInterpreter(goSource)
+
+	if interp != nil {
+		mu.Lock()
+		interpreters[nextID] = interp
+		nextID++
+		mu.Unlock()
+	}
+
+	cResult := C.CString(result)
+	if cResult == nil {
+		return C.CString(`{"success":false,"error":"Failed to allocate C string"}`)
+	}
+	return cResult
+}
+
+//export quill_step
+func quill_step(interpID C.int) *C.char {
+	mu.Lock()
+	interp, exists := interpreters[int(interpID)]
+	mu.Unlock()
+
+	if !exists {
+		return C.CString(`{"success":false,"error":"Invalid interpreter ID"}`)
+	}
+
+	result := interp.Step()
+	cResult := C.CString(result)
+	if cResult == nil {
+		return C.CString(`{"success":false,"error":"Failed to allocate C string"}`)
+	}
+	return cResult
+}
+
+//export quill_handle_choice
+func quill_handle_choice(interpID C.int, choiceIndex C.int) *C.char {
+	mu.Lock()
+	interp, exists := interpreters[int(interpID)]
+	mu.Unlock()
+
+	if !exists {
+		return C.CString(`{"success":false,"error":"Invalid interpreter ID"}`)
+	}
+
+	result := interp.HandleChoiceInput(int(choiceIndex))
+	cResult := C.CString(result)
+	if cResult == nil {
+		return C.CString(`{"success":false,"error":"Failed to allocate C string"}`)
+	}
+	return cResult
+}
+
+//export quill_get_state
+func quill_get_state(interpID C.int) *C.char {
+	mu.Lock()
+	interp, exists := interpreters[int(interpID)]
+	mu.Unlock()
+
+	if !exists {
+		return C.CString(`{"success":false,"error":"Invalid interpreter ID"}`)
+	}
+
+	result := interp.GetState()
+	cResult := C.CString(result)
+	if cResult == nil {
+		return C.CString(`{"success":false,"error":"Failed to allocate C string"}`)
+	}
+	return cResult
+}
+
+//export quill_is_ended
+func quill_is_ended(interpID C.int) *C.char {
+	mu.Lock()
+	interp, exists := interpreters[int(interpID)]
+	mu.Unlock()
+
+	if !exists {
+		return C.CString(`{"success":false,"error":"Invalid interpreter ID"}`)
+	}
+
+	result := interp.IsEnded()
+	cResult := C.CString(result)
+	if cResult == nil {
+		return C.CString(`{"success":false,"error":"Failed to allocate C string"}`)
+	}
+	return cResult
+}
+
+//export quill_is_waiting_for_choice
+func quill_is_waiting_for_choice(interpID C.int) *C.char {
+	mu.Lock()
+	interp, exists := interpreters[int(interpID)]
+	mu.Unlock()
+
+	if !exists {
+		return C.CString(`{"success":false,"error":"Invalid interpreter ID"}`)
+	}
+
+	result := interp.IsWaitingForChoice()
+	cResult := C.CString(result)
+	if cResult == nil {
+		return C.CString(`{"success":false,"error":"Failed to allocate C string"}`)
+	}
+	return cResult
+}
+
+//export quill_parse_only
+func quill_parse_only(source *C.char) *C.char {
+	goSource := C.GoString(source)
+	result := jsonapi.ParseOnly(goSource)
+	cResult := C.CString(result)
+	if cResult == nil {
+		return C.CString(`{"success":false,"error":"Failed to allocate C string"}`)
+	}
+	return cResult
+}
+
+//export quill_free_string
+func quill_free_string(str *C.char) {
+	C.free(unsafe.Pointer(str))
+}
+
+//export quill_free_interpreter
+func quill_free_interpreter(interpID C.int) {
+	mu.Lock()
+	delete(interpreters, int(interpID))
+	mu.Unlock()
+}
+
+func main() {}

examples/c/example.c

@@ -0,0 +1,99 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include "libquill.h"
+
+// Simple function to extract interpreter ID from JSON response
+// In a real application, you'd use a proper JSON parser
+int extract_interpreter_id(const char* json_response) {
+    // Look for "success":true first
+    if (strstr(json_response, "\"success\":true") == NULL) {
+        return -1; // Error case
+    }
+    
+    // This is a very basic extraction - in practice use a JSON library
+    // The response should contain the interpreter ID
+    // For now, we'll return a hardcoded value since the Go code doesn't 
+    // actually include the ID in the response
+    return 1;
+}
+
+int main() {
+    const char* source = 
+        "ALEX: \"Hello there!\"\n"
+        "BELLA: \"Hi Alex!\"\n"
+        "\n"
+        "CHOICE {\n"
+        "    \"How are you?\" {\n"
+        "        ALEX: \"I'm doing great, thanks!\"\n"
+        "    },\n"
+        "    \"What's new?\" {\n"
+        "        ALEX: \"Not much, just working on some projects.\"\n"
+        "    }\n"
+        "}\n"
+        "\n"
+        "ALEX: \"Thanks for asking!\"\n"
+        "END\n";
+
+    printf("=== Quill C API Test ===\n\n");
+
+    // Test parse only
+    printf("1. Testing parse only:\n");
+    char* parse_result = quill_parse_only(source);
+    printf("Parse result: %s\n\n", parse_result);
+    quill_free_string(parse_result);
+
+    // Create interpreter
+    printf("2. Creating interpreter:\n");
+    char* init_result = quill_new_interpreter(source);
+    printf("Init result: %s\n\n", init_result);
+    
+    // Extract interpreter ID from response
+    int interp_id = extract_interpreter_id(init_result);
+    if (interp_id == -1) {
+        printf("Failed to create interpreter\n");
+        quill_free_string(init_result);
+        return 1;
+    }
+    
+    quill_free_string(init_result);
+
+    // Test interpreter methods
+    printf("3. Testing interpreter methods:\n");
+    
+    // Get initial state
+    char* state = quill_get_state(interp_id);
+    printf("Initial state: %s\n", state);
+    quill_free_string(state);
+
+    // Step through execution
+    for (int i = 0; i < 5; i++) {
+        printf("\n--- Step %d ---\n", i + 1);
+        
+        char* step_result = quill_step(interp_id);
+        printf("Step result: %s\n", step_result);
+        quill_free_string(step_result);
+
+        // Check if waiting for choice
+        char* waiting = quill_is_waiting_for_choice(interp_id);
+        printf("Waiting for choice: %s\n", waiting);
+        
+        // For demo purposes, always choose option 0 if waiting
+        // In real usage, you'd parse the JSON to check the boolean value
+        char* choice_result = quill_handle_choice(interp_id, 0);
+        printf("Choice result: %s\n", choice_result);
+        quill_free_string(choice_result);
+        quill_free_string(waiting);
+
+        // Check if ended
+        char* ended = quill_is_ended(interp_id);
+        printf("Is ended: %s\n", ended);
+        quill_free_string(ended);
+    }
+
+    // Clean up
+    quill_free_interpreter(interp_id);
+    
+    printf("\n=== Test Complete ===\n");
+    return 0;
+}

internal/interpreter/interpreter.go

@@ -23,19 +23,19 @@ type InterpreterResult struct {
 }
 
 type DialogData struct {
-	Character string
-	Text      string
-	Tags      []string
+	Character string   `json:"character"`
+	Text      string   `json:"text"`
+	Tags      []string `json:"tags"`
 }
 
 type ChoiceOption struct {
-	Index int
-	Text  string
-	Tags  []string
+	Index int      `json:"index"`
+	Text  string   `json:"text"`
+	Tags  []string `json:"tags"`
 }
 
 type ChoiceData struct {
-	Options []ChoiceOption
+	Options []ChoiceOption `json:"options"`
 }
 
 type ExecutionState int
@@ -69,8 +69,8 @@ type InterpreterError struct {
 }
 
 type ErrorData struct {
-	Message string
-	Line    int
+	Message string `json:"message"`
+	Line    int    `json:"line"`
 }
 
 func New(program *ast.Program) *Interpreter {