framework

conanfile.py

@@ -20,7 +20,7 @@ class helloConan(ConanFile):
         self.folders.build = "build"
 
     def requirements(self):
-        self.requires("zlib/1.2.11")
+        self.requires("cwalk/1.2.8")
 
     def generate(self):
         deps = PkgConfigDeps(self)

meson.build

@@ -3,11 +3,11 @@ project('tutorial', 'c')
 CC = meson.get_compiler('c')
 target_name = 'main'
 
-
-zlib = dependency('zlib', version : '1.2.11', static: true, required: true)
+# self.requires("zlib/1.2.11")
+cwalk = dependency('cwalk', version : '1.2.8', static: true, required: true)
 
 
-files = files('src/main.c')
+files = files('src/main.c', 'src/paths.c', 'src/log.c')
 
 if get_option('buildtype') == 'debug'
   if CC.has_argument('-fsanitize=address') and CC.has_link_argument('-fsanitize=address')
@@ -18,6 +18,6 @@ if get_option('buildtype') == 'debug'
 endif
 
 
-executable(target_name, files, dependencies: [zlib], include_directories: include_directories('src/include'))
+executable(target_name, files, dependencies: [cwalk], include_directories: include_directories('src/include'))
 
 

src/include/log.h

@@ -0,0 +1,49 @@
+/**
+ * Copyright (c) 2020 rxi
+ *
+ * This library is free software; you can redistribute it and/or modify it
+ * under the terms of the MIT license. See `log.c` for details.
+ */
+
+#ifndef LOG_H
+#define LOG_H
+
+#include <stdio.h>
+#include <stdarg.h>
+#include <stdbool.h>
+#include <time.h>
+
+#define LOG_VERSION "0.1.0"
+
+typedef struct {
+  va_list ap;
+  const char *fmt;
+  const char *file;
+  struct tm *time;
+  void *udata;
+  int line;
+  int level;
+} log_Event;
+
+typedef void (*log_LogFn)(log_Event *ev);
+typedef void (*log_LockFn)(bool lock, void *udata);
+
+enum { LOG_TRACE, LOG_DEBUG, LOG_INFO, LOG_WARN, LOG_ERROR, LOG_FATAL };
+
+#define log_trace(...) log_log(LOG_TRACE, __FILE__, __LINE__, __VA_ARGS__)
+#define log_debug(...) log_log(LOG_DEBUG, __FILE__, __LINE__, __VA_ARGS__)
+#define log_info(...)  log_log(LOG_INFO,  __FILE__, __LINE__, __VA_ARGS__)
+#define log_warn(...)  log_log(LOG_WARN,  __FILE__, __LINE__, __VA_ARGS__)
+#define log_error(...) log_log(LOG_ERROR, __FILE__, __LINE__, __VA_ARGS__)
+#define log_fatal(...) log_log(LOG_FATAL, __FILE__, __LINE__, __VA_ARGS__)
+
+const char* log_level_string(int level);
+void log_set_lock(log_LockFn fn, void *udata);
+void log_set_level(int level);
+void log_set_quiet(bool enable);
+int log_add_callback(log_LogFn fn, void *udata, int level);
+int log_add_fp(FILE *fp, int level);
+
+void log_log(int level, const char *file, int line, const char *fmt, ...);
+
+#endif

src/include/paths.h

@@ -0,0 +1,4 @@
+char* appdata_path();
+int folder_exists(const char* path);
+int setup_appdata();
+char* custom_appdata_path(const char* folder_name);

src/log.c

@@ -0,0 +1,168 @@
+/*
+ * Copyright (c) 2020 rxi
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to
+ * deal in the Software without restriction, including without limitation the
+ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+ * sell copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+ * IN THE SOFTWARE.
+ */
+#include <stdio.h>
+#include "log.h"
+
+#define MAX_CALLBACKS 32
+
+typedef struct {
+  log_LogFn fn;
+  void *udata;
+  int level;
+} Callback;
+
+static struct {
+  void *udata;
+  log_LockFn lock;
+  int level;
+  bool quiet;
+  Callback callbacks[MAX_CALLBACKS];
+} L;
+
+
+static const char *level_strings[] = {
+  "TRACE", "DEBUG", "INFO", "WARN", "ERROR", "FATAL"
+};
+
+#ifdef LOG_USE_COLOR
+static const char *level_colors[] = {
+  "\x1b[94m", "\x1b[36m", "\x1b[32m", "\x1b[33m", "\x1b[31m", "\x1b[35m"
+};
+#endif
+
+
+static void stdout_callback(log_Event *ev) {
+  char buf[16];
+  buf[strftime(buf, sizeof(buf), "%H:%M:%S", ev->time)] = '\0';
+#ifdef LOG_USE_COLOR
+  fprintf(
+    ev->udata, "%s %s%-5s\x1b[0m \x1b[90m%s:%d:\x1b[0m ",
+    buf, level_colors[ev->level], level_strings[ev->level],
+    ev->file, ev->line);
+#else
+  fprintf(
+    ev->udata, "%s %-5s %s:%d: ",
+    buf, level_strings[ev->level], ev->file, ev->line);
+#endif
+  vfprintf(ev->udata, ev->fmt, ev->ap);
+  fprintf(ev->udata, "\n");
+  fflush(ev->udata);
+}
+
+
+static void file_callback(log_Event *ev) {
+  char buf[64];
+  buf[strftime(buf, sizeof(buf), "%Y-%m-%d %H:%M:%S", ev->time)] = '\0';
+  fprintf(
+    ev->udata, "%s %-5s %s:%d: ",
+    buf, level_strings[ev->level], ev->file, ev->line);
+  vfprintf(ev->udata, ev->fmt, ev->ap);
+  fprintf(ev->udata, "\n");
+  fflush(ev->udata);
+}
+
+
+static void lock(void)   {
+  if (L.lock) { L.lock(true, L.udata); }
+}
+
+
+static void unlock(void) {
+  if (L.lock) { L.lock(false, L.udata); }
+}
+
+
+const char* log_level_string(int level) {
+  return level_strings[level];
+}
+
+
+void log_set_lock(log_LockFn fn, void *udata) {
+  L.lock = fn;
+  L.udata = udata;
+}
+
+
+void log_set_level(int level) {
+  L.level = level;
+}
+
+
+void log_set_quiet(bool enable) {
+  L.quiet = enable;
+}
+
+
+int log_add_callback(log_LogFn fn, void *udata, int level) {
+  for (int i = 0; i < MAX_CALLBACKS; i++) {
+    if (!L.callbacks[i].fn) {
+      L.callbacks[i] = (Callback) { fn, udata, level };
+      return 0;
+    }
+  }
+  return -1;
+}
+
+
+int log_add_fp(FILE *fp, int level) {
+  return log_add_callback(file_callback, fp, level);
+}
+
+
+static void init_event(log_Event *ev, void *udata) {
+  if (!ev->time) {
+    time_t t = time(NULL);
+    ev->time = localtime(&t);
+  }
+  ev->udata = udata;
+}
+
+
+void log_log(int level, const char *file, int line, const char *fmt, ...) {
+  log_Event ev = {
+    .fmt   = fmt,
+    .file  = file,
+    .line  = line,
+    .level = level,
+  };
+
+  lock();
+
+  if (!L.quiet && level >= L.level) {
+    init_event(&ev, stderr);
+    va_start(ev.ap, fmt);
+    stdout_callback(&ev);
+    va_end(ev.ap);
+  }
+
+  for (int i = 0; i < MAX_CALLBACKS && L.callbacks[i].fn; i++) {
+    Callback *cb = &L.callbacks[i];
+    if (level >= cb->level) {
+      init_event(&ev, cb->udata);
+      va_start(ev.ap, fmt);
+      cb->fn(&ev);
+      va_end(ev.ap);
+    }
+  }
+
+  unlock();
+}

src/main.c

@@ -1,51 +1,19 @@
 #include <stdlib.h>
 #include <stdio.h>
 #include <string.h>
+#include <paths.h>
 #ifdef _WIN32
 #include <windows.h>
 #elif __linux__ || __APPLE__
 #include <unistd.h>
 #endif
 
-#include <zlib.h>
-
-void sleep_ms(int milliseconds) {
-#ifdef _WIN32
-    Sleep(milliseconds);
-#elif __linux__ || __APPLE__
-    usleep(milliseconds * 1000); // Convert milliseconds to microseconds
-#endif
-}
 
 int main(void) {
-    char buffer_in [256] = {"Conan is a MIT-licensed, Open Source package manager for C and C++ development "
-                            "for C and C++ development, allowing development teams to easily and efficiently "
-                            "manage their packages and dependencies across platforms and build systems."};
-    char buffer_out [256] = {0};
-
-    z_stream defstream;
-    defstream.zalloc = Z_NULL;
-    defstream.zfree = Z_NULL;
-    defstream.opaque = Z_NULL;
-    defstream.avail_in = (uInt) strlen(buffer_in);
-    defstream.next_in = (Bytef *) buffer_in;
-    defstream.avail_out = (uInt) sizeof(buffer_out);
-    defstream.next_out = (Bytef *) buffer_out;
-
-    deflateInit(&defstream, Z_BEST_COMPRESSION);
-    deflate(&defstream, Z_FINISH);
-    deflateEnd(&defstream);
-
-    unsigned long long compressed_size = sizeof(buffer_out) - defstream.avail_out;
-
-    int x = 1-1;
-
-    
-
-    printf("Uncompressed size is: %lu\n", strlen(buffer_in));
-    printf("Compressed size is: %lu\n", strlen(buffer_out));
-
-    printf("ZLIB VERSION: %s\n", zlibVersion());
-
-    return EXIT_SUCCESS;
+    puts("Hello, World!");
+    setup_appdata();
+    printf_s("Appdata path: %s\n", appdata_path());
+    const char *cupath = custom_appdata_path("CustomFolder");
+    printf_s("Custom appdata path: %s\n", cupath);
+    return 0;
 }

src/paths.c

@@ -0,0 +1,63 @@
+#include <cwalk.h>
+#include <sys/stat.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <log.h>
+
+#define APPDATA_FOLDER "TodoC"
+
+// how do i make a function that returns a string?
+// a: char* get_path(const char* path) {
+//     char* result = (char*)malloc(256);
+    // if (result == NULL) {
+    //     return NULL; // Handle memory allocation failure
+
+char* appdata_path() {
+    log_debug("Getting appdata path");
+    char* path = malloc(256);
+    cwk_path_join(getenv("APPDATA"), APPDATA_FOLDER, path, 256);
+    log_debug("Appdata path: %s", path);
+    return path;
+}
+
+int folder_exists(const char* path) {
+    struct stat sb;
+
+    if (stat(path, &sb) == 0 && S_ISDIR(sb.st_mode)) {
+        return 1; // Directory exists
+    } else {
+        return 0; // Directory does not exist
+    }
+}
+
+int setup_appdata() {
+    char* path = appdata_path();
+
+    if (!folder_exists(path)) {
+        mkdir(path);
+        log_debug("Appdata folder created: %s", path);
+        free(path);
+        return -1; // Handle path existence check failure
+    }
+
+    log_debug("Appdata folder already exists: %s", path);
+    mkdir(path);
+    free(path);
+    return 0; // no change
+}    
+
+
+char* custom_appdata_path(const char* folder_name) {
+    
+    char *path = malloc(256);
+    cwk_path_join(appdata_path(), folder_name, path, 256);
+
+    if (!folder_exists(path)) {
+        log_debug("Custom appdata folder does not exist, creating: %s", path);
+        mkdir(path);
+    } else {
+        log_debug("Custom appdata folder already exists: %s", path);
+    }
+
+    return path;
+}

src/todoitem.c

@@ -0,0 +1,26 @@
+#include <stdio.h>
+#include <stdlib.h>
+
+typedef struct {
+    char *name;
+    char *description;
+    int priority;
+    int completed;
+} todoitem;
+
+ todoitem *create_todoitem(char *name, char *description, int priority, int completed) {
+    todoitem *item = malloc(sizeof(todoitem));
+    item->name = name;
+    item->description = description;
+    item->priority = priority;
+    item->completed = completed;
+    return item;
+}
+
+void free_todoitem(todoitem *item) {
+    if (item != NULL) {
+        free(item->name);
+        free(item->description);
+        free(item);
+    }
+}