Recreating Fable.jl

.gitignore

@@ -59,8 +59,7 @@ CMake*
 cmake*
 *.bak
 
-# Julia docs
-docs/build/*
 docs/Manifest.toml
 
 quibble
+qbinfo

CMakeLists.txt

@@ -1,19 +1,61 @@
 cmake_minimum_required (VERSION 3.8)
 
+set(CMAKE_C_COMPILER clang)
 project (Quibble LANGUAGES C)
 find_package(OpenCL REQUIRED)
 
+if (MSVC)
+    add_compile_options(/W4)
+else()
+    add_compile_options(-Wall -Wextra -Wpedantic -Wno-varargs)
+endif()
+
+set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib)
+set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib)
+set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin)
+
+# QUIBBLE
+
 add_executable(
     quibble
     include/macros.h
 
     include/errors.h
     src/errors.c
 
-    include/demo_functions.h
-    src/demo_functions.c
+    include/io.h
+    src/io.c
+
+    include/quibble_args.h
+    src/quibble_args.c
+
+    include/quibble_program.h
+    src/quibble_verses.c
+    src/quibble_stanzas.c
+    src/quibble_poems.c
+    src/quibble_program.c
+
+    test/tests.h
+    test/io_tests.c
+    test/program_tests.c
 
     src/demo.c
 )
 
 target_link_libraries(quibble OpenCL::OpenCL)
+
+# QBINFO
+
+add_executable(
+    qbinfo
+
+    include/errors.h
+    src/errors.c
+
+    include/qbinfo.h
+    src/qbinfo.c
+)
+
+target_link_libraries(qbinfo OpenCL::OpenCL)
+
+execute_process(COMMAND bash ${PROJECT_SOURCE_DIR}/configure)

clean

@@ -0,0 +1,9 @@
+#!/bin/bash
+if [ -z ${XDG_CONFIG_HOME+x} ]; \
+    then config_dir="$HOME/.config/quibble"; echo "XDG_CONFIG_HOME is unset, attempting to clean $config_dir"; \
+    else config_dir="$XDG_CONFIG_HOME/quibble"; echo "attempting to clean $config_dir..."; \
+fi
+
+rm -r $config_dir
+
+echo "done!"

configure

@@ -0,0 +1,11 @@
+#!/bin/bash
+cd $(dirname $0)
+if [ -z ${XDG_CONFIG_HOME+x} ]; \
+    then config_dir="$HOME/.config/quibble"; echo "XDG_CONFIG_HOME is unset, using $config_dir"; \
+    else config_dir="$XDG_CONFIG_HOME/quibble"; echo "using $config_dir..."; \
+fi
+
+mkdir -p $config_dir/scribbles
+cp scribbles/* $config_dir/scribbles/.
+
+echo "done!"

include/errors.h

@@ -7,6 +7,18 @@
 #include "macros.h"
 #include <CL/cl.h>
 
+#include <stdio.h>
+#include <stdlib.h>
+
+// QBT -> Quibble Text
+#define QBT_RED     "\x1b[31m"
+#define QBT_GREEN   "\x1b[32m"
+#define QBT_YELLOW  "\x1b[33m"
+#define QBT_BLUE    "\x1b[34m"
+#define QBT_MAGENTA "\x1b[35m"
+#define QBT_CYAN    "\x1b[36m"
+#define QBT_RESET   "\x1b[0m"
+
 void cl_check(cl_int error);
 
 const char *get_cl_error_string(cl_int error);

include/io.h

@@ -0,0 +1,42 @@
+#ifndef IO_H
+#define IO_H
+
+#include <stdlib.h>
+#include <string.h>
+#include <png.h>
+#include <stdlib.h>
+
+typedef struct {
+    unsigned char red;
+    unsigned char green;
+    unsigned char blue;
+    unsigned char alpha;
+} quibble_pixel;
+
+quibble_pixel qb_zero_pixel(void);
+quibble_pixel *qb_create_pixel_array(int height, int width);
+
+char *qb_config_file(char *path);
+
+size_t qb_find_type_size(char *type);
+
+// String Manipulation
+bool qb_is_space(char a);
+char *qb_copy(char *buffer);
+char *qb_strip_spaces(char *body, int start_index, int end_index);
+int qb_find_next_char(char *body, int current_index, char a);
+int qb_find_next_string(char *body, int current_index, char *a);
+int qb_find_matching_char(char *body, int body_size, int current_index,
+                          char a, char b);
+
+void qb_replace_char(char *body, int body_size, char a, char b);
+void qb_replace_next_char(char *content, int index, char a, char b);
+void qb_replace_char_if_proceeding(char *content, char *query, char a, char b);
+
+int qb_find_occurrences(char *query, char *body);
+
+// QBINLINE
+bool qb_is_inlined(char *verse);
+void qb_preprocess_content(char *verse);
+
+#endif

include/macros.h

@@ -1,9 +1,17 @@
 #ifndef MACROS_H
 #define MACROS_H
 
-//#define MAX_SOURCE_SIZE (0x100000)
+// These numbers are arbitrarily set
+// #define MAX_SOURCE_SIZE (0x100000)
 #define MAX_SOURCE_SIZE (0x999999)
+#define MAX_PROLOGUE_SIZE (0x100000)
+#define MAX_META_SIZE (0x100000)
 
+// I might want to ise 1.2 in the end...
 #define CL_TARGET_OPENCL_VERSION 300
+//#define CL_TARGET_OPENCL_VERSION 120
+
+// Delay Compilation
+#define QBINLINE(...) "// QBINLINE GENERATED\n" #__VA_ARGS__ "\0"
 
 #endif

include/qbinfo.h

@@ -0,0 +1,12 @@
+#ifndef QB_INFO_H
+#define QB_INFO_H
+
+#include "errors.h"
+#include "macros.h"
+#include <CL/cl.h>
+
+char *get_device_name(cl_device_id device_id);
+char *get_platform_name(cl_platform_id platform_id);
+void qb_list_devices(void);
+
+#endif

include/quibble_args.h

@@ -0,0 +1,51 @@
+#ifndef QUIBBLE_ARGS_H
+#define QUIBBLE_ARGS_H
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <stdbool.h>
+
+#include "macros.h"
+#include "io.h"
+
+typedef struct{
+    char *type;
+    char *variable;
+} quibble_arg;
+
+typedef struct{
+    char *type;
+    char *variable;
+    char *value;
+} quibble_kwarg;
+
+void qb_find_type_arg(char *arg, char **type, char **variable);
+void qb_parse_arg(quibble_arg *qa, char *arg);
+void qb_parse_kwarg(quibble_kwarg *qk, char *lhs, char *rhs);
+
+// Args / Kwargs
+int qb_find_number_of_kwargs(char *config);
+int qb_find_number_of_args(char *config);
+
+quibble_arg *qb_parse_args(char *config, int num_entries);
+quibble_kwarg *qb_parse_kwargs(char *config, int num_entries);
+
+int qb_find_arg_index(quibble_arg *arg, int n, char *variable);
+int qb_find_kwarg_index(quibble_kwarg *qk, int n, char *variable);
+
+// prologue
+char *qb_create_prologue(char *config, char *name,
+                         quibble_arg *qargs, int num_args,
+                         quibble_kwarg *qkwargs, int num_kwargs);
+
+// Free
+void qb_free_arg(quibble_arg arg);
+void qb_free_kwarg(quibble_kwarg qkwarg);
+void qb_free_arg_array(quibble_arg *args, int n);
+void qb_free_kwarg_array(quibble_kwarg *qkwargs, int n);
+
+// Printing
+void qb_print_arg(quibble_arg qa);
+void qb_print_kwarg(quibble_kwarg qk);
+
+#endif

include/quibble_program.h

@@ -0,0 +1,136 @@
+#ifndef QUIBBLE_PROGRAM_H
+#define QUIBBLE_PROGRAM_H
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <stdbool.h>
+#include <stdarg.h>
+
+#include "macros.h"
+#include <CL/cl.h>
+#include "io.h"
+#include "errors.h"
+#include "quibble_args.h"
+
+typedef struct{
+    char *body;
+    char *name;
+    quibble_kwarg *kwargs;
+    quibble_arg *args;
+    int num_kwargs;
+    int num_args;
+} quibble_verse;
+
+typedef struct{
+    quibble_kwarg *kwargs;
+    int num_kwargs;
+    quibble_arg *args;
+    int num_args;
+    char *name;
+    char *prologue;
+    char *epilogue;
+} quibble_stanza;
+
+typedef struct{
+    quibble_arg *args;
+    int num_args;
+    char *body;
+    char *name;
+} quibble_poem;
+
+typedef struct{
+    char *everything_else;
+    char *body;
+    quibble_verse *verse_list;
+    quibble_stanza *stanza_list;
+    quibble_poem *poem_list;
+    int num_verses;
+    int num_stanzas;
+    int num_poems;
+
+    // CL stuff
+    cl_platform_id *platform_ids;
+    cl_device_id *device_ids;
+    cl_uint num_devices;
+    cl_uint num_platforms;
+    int chosen_platform;
+    int chosen_device;
+    cl_context context;
+    cl_command_queue command_queue;
+    cl_program program;
+    cl_kernel *kernels;
+    bool configured;
+
+} quibble_program;
+
+// OpenCL Interface
+char *get_device_name(cl_device_id device_id);
+char *get_platform_name(cl_platform_id platform_id);
+void qb_find_platforms(quibble_program *qp);
+void qb_find_devices(quibble_program *qp);
+void qb_configure_program(quibble_program *qp, int platform, int device);
+void qb_run(quibble_program qp, char *kernel_name,
+            size_t global_item_size,
+            size_t local_item_size);
+void qb_set_arg(quibble_program *qp, char *poem, char *arg, void *data);
+void qb_set_args(quibble_program *qp, char *poem, int n, ...);
+
+
+// string manip
+bool qb_is_stanza(char *stanza, int offset);
+bool qb_is_poem(char *poem, int offset);
+bool qb_is_verse(char *verse, int offset);
+
+// Reads an input file and parses everything into verses or OCL functions
+quibble_program qb_parse_program(char *buffer);
+quibble_program qb_parse_program_file(char *filename);
+quibble_verse qb_find_verse(quibble_program qp, char *verse_name);
+quibble_stanza qb_find_stanza(quibble_program qp, char *stanza_name);
+quibble_poem qb_find_poem(quibble_program qp, char *poem_name);
+int qb_find_verse_index(quibble_program qp, char *verse_name);
+int qb_find_stanza_index(quibble_program qp, char *stanza_name);
+int qb_find_poem_index(quibble_program qp, char *poem_name);
+
+// Parsing from file
+quibble_stanza qb_parse_stanza(char *stanza);
+quibble_poem qb_parse_poem(char *stanza);
+quibble_verse qb_parse_verse(char *verse);
+
+// Build / expansion
+bool qb_find_keyword(quibble_program qp, char *keyword);
+bool qb_find_keyword_in_verses(quibble_program qp, char *keyword);
+bool qb_find_keyword_in_stanzas(quibble_program qp, char *keyword);
+bool qb_find_keyword_in_poems(quibble_program qp, char *keyword);
+char *qb_create_prologue(char *config, char *name,
+                         quibble_arg *args, int num_args,
+                         quibble_kwarg *qkwargs, int num_kwargs);
+void qb_build_program(quibble_program *qp);
+void qb_rebuild_program(quibble_program *qp);
+char *qb_expand_verse(quibble_program qp, char* verse_name, char *prologue);
+char *qb_expand_stanza(quibble_program qp,
+                       char* stanza_name, char *prologue, char *body);
+char *qb_expand_poem(quibble_program qp, int index);
+
+void qb_rebuild_program(quibble_program *qp);
+void qb_build_program(quibble_program *qp);
+
+// Free
+void qb_free_arg(quibble_arg arg);
+void qb_free_kwarg(quibble_kwarg qkwarg);
+void qb_free_verse(quibble_verse qv);
+void qb_free_stanza(quibble_stanza qs);
+void qb_free_poem(quibble_poem qp);
+void qb_free_kwarg_array(quibble_kwarg *qkwargs, int n);
+void qb_free_arg_array(quibble_arg *args, int n);
+void qb_free_program(quibble_program qp);
+
+// Printing
+void qb_print_arg(quibble_arg qa);
+void qb_print_kwarg(quibble_kwarg qk);
+void qb_print_verse(quibble_verse qv);
+void qb_print_stanza(quibble_stanza qs);
+void qb_print_poem(quibble_poem qp);
+void qb_print_program(quibble_program qp);
+void print_cl_info(quibble_program qp);
+
+#endif