demake 0.1.2 → 0.2.1

data/lib/apps/oreo/src/oreo.c

@@ -0,0 +1,102 @@
+/*
+   oreo.c -- A simple c program that reads data piped in, issued as arguments or from a file and echos output
+
+   Program main entry point: _start/main
+*/
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+/* Cross platform test to see if data has been piped from stdin */
+#if defined(_WIN32) || defined(__WIN32__) || defined(WIN32)
+  #include <io.h>
+  #define piped_from_stdin      !_isatty(fileno(stdin))
+#else
+  #include <unistd.h>
+  #define piped_from_stdin      !isatty(fileno(stdin))
+#endif
+
+/* Cross platform test to see if data has been piped from stdin - Option 2 */
+/*
+#if defined(_WIN32) || defined(__WIN32__) || defined(WIN32)
+  #include <windows.h>
+#else
+  #include <sys/ioctl.h>
+#endif
+*/
+
+#include "defines.h"
+#include "typedefs.h"
+#define FAST_READ_FILE_IMPLEMENTATION
+#include "fast_read_file.h"
+
+i32 main(i32 argc, c8 **argv)
+{
+  FILE *file = NULL;
+  u64 total_bytes = 0, l = 0;
+  i32 n = 0;
+  c8 *string = NULL;
+  b8 displayed = FALSE;
+
+/* Cross platform test to see if data has been piped from stdin - Option 2 */
+/*
+#if defined(_WIN32) || defined(__WIN32__) || defined(WIN32)
+  HANDLE stdin_handle = GetStdHandle(STD_INPUT_HANDLE);
+  DWORD bytes;
+
+  if(PeekNamedPipe(stdin_handle, NULL, 0, NULL, &bytes, NULL) && bytes > 0) {
+#else
+  if(ioctl(0, FIONREAD, &n) == 0 && n > 0) {
+#endif
+*/
+
+  if(piped_from_stdin) {
+    string = (c8 *)fast_read_all_file_aligned(stdin, &total_bytes);
+#ifdef OREO_DEBUG
+    printf("From stdin:\r\n");
+#endif
+    printf("oreo: %s\r\n", string);
+    free_all_aligned_read_memory(string);
+    string = NULL;
+    displayed = TRUE;
+  }
+  if(argv[1] != NULL) {
+    file = fopen(argv[1], "r");
+    if(file == NULL) {
+      /* We need to manually recreate the command input based on arguments with spaces */
+      for(n = 1; n < argc; n++) {
+        if(string != NULL) {
+          l = (u32)strlen(argv[n]);
+          total_bytes += l + 1;					/* +1 for space         */
+          string = realloc(string, (size_t)total_bytes + 1);	/* +1 for \0            */
+          strncat((c8 *)string, " ", (size_t)2);		/* 2 for space and \0	*/
+          strncat((c8 *)string, argv[n], l);
+        } else {
+          total_bytes = (u32)strlen(argv[n]);
+          string = calloc(total_bytes + 1, sizeof(c8));		/* +1 for \0            */
+          strncpy((c8 *)string, argv[n], total_bytes);
+        }
+      }
+#ifdef OREO_DEBUG
+      printf("From argument:\r\n");
+#endif
+      printf("oreo: %s\r\n", string);
+      free(string);
+      string = NULL;
+    } else {
+#ifdef OREO_DEBUG
+      printf("From file: %s\r\n", argv[1]);
+#endif
+      string = (c8 *)fast_read_all_file_mapped(file, &total_bytes);
+      printf("oreo: %s\r\n", string);
+      free_all_mapped_read_memory(string, &total_bytes);
+      string = NULL;
+    }
+  } else if(!displayed) {
+#ifdef OREO_DEBUG
+    printf("No input provided.\r\n");
+#endif
+  }
+  exit(0);
+}

data/lib/apps/oreo/src/typedefs.h

@@ -0,0 +1,61 @@
+/*
+
+  typedefs.h -- Include and typedefs for basic C types
+
+  These typedefs appear in all full library header files.
+
+  You can override all of them by including this file first and making your changes here.
+
+  To add text editor color highlight support for these typedefs see below.
+
+*/
+
+#ifndef TYPEDEFS_H_Minaswan	/* Prevents multiple inclusions */
+  #define TYPEDEFS_H_Minaswan
+  #define TYPEDEFS_VERSION	"0.1.0"
+  #include <stdint.h>
+
+  typedef uint8_t b8;		/* Booleans			*/
+  typedef uint16_t b16;
+  typedef uint32_t b32;
+  typedef uint64_t b64;
+
+  typedef char c8;		/* Characters			*/
+  typedef unsigned char uc8;
+
+  typedef uint8_t u8;		/* Unsigned Numbers		*/
+  typedef uint16_t u16;
+  typedef uint32_t u32;
+  typedef uint64_t u64;
+
+  typedef int8_t i8;		/* Signed Numbers		*/
+  typedef int16_t i16;
+  typedef int32_t i32;
+  typedef int64_t i64;
+
+  typedef float f32;		/* Floating Point Numbers	*/
+  typedef double f64;
+#endif				/* TYPEDEFS_H_Minaswan		*/
+
+/*
+
+For nvim, add to ~/.config/nvim/init.lua:
+
+vim.cmd("syntax on")
+vim.api.nvim_create_augroup("CustomCTypedefs", { clear = true })
+vim.api.nvim_create_autocmd("FileType", {
+    group = "CustomCTypedefs",
+    pattern = { "c", "h", "cpp", "hpp" },
+    callback = function()
+        vim.cmd([[syntax match CustomTypedef /\<\(b8\|b16\|b32\|b64\|c8\|uc8\|i8\|i16\|i32\|i64\|u8\|u16\|u32\|u64\|f32\|f64\)\>/]])
+        vim.cmd([[highlight CustomTypedef guifg=green ctermfg=green]])
+    end,
+})
+
+For nano, add to /usr/share/nano/c.nanorc:
+
+color green "\<(b8|b16|b32|b64|c8|uc8|i8|i16|i32|i64|u8|u16|u32|u64|f32|f64)\>"
+
+For emacs, it would seem the magic is strong, because it just works. :)
+
+*/

data/lib/data/libsrc/auto_bits.h

@@ -0,0 +1,33 @@
+/*
+
+  auto_bits.h -- *Full Library* Header File
+
+  For auto bits
+
+  See the end of this file for an example.
+
+  Public Functions:
+
+*/
+
+#ifndef AUTO_BITS_H_Minaswan		/* Prevent multiple inclusions */
+#define AUTO_BITS_H_Minaswan
+  #ifndef TYPEDEFS_H_Minaswan		/* Header guard for typedefs.h */
+    #define TYPEDEFS_H_Minaswan
+
+  #endif				/* TYPEDEFS_H_Minaswan */
+
+  /* Public Functions */
+
+  #ifdef AUTO_BITS_IMPLEMENTATION
+
+  #endif	/* AUTO_BITS_IMPLEMENTATION */
+#endif		/* AUTO_BITS_H_Minaswan */
+
+/*
+  Example:
+
+  #define AUTO_BITS_IMPLEMENTATION
+  #include "auto_bits.h"
+
+*/

data/lib/data/libsrc/base.h

@@ -0,0 +1,10 @@
+/*
+   base.h -- Light weight C Environment Setup
+*/
+
+#ifndef BASE_H_Minaswan	/* Header guard to prevent multiple inclusions */
+  #define BASE_H_Minaswan
+  #define BASE_VERSION		"0.1.0"
+  #include "defines.h"
+  #include "typedefs.h"
+#endif /* BASE_H_Minaswan */

data/lib/data/libsrc/cpu_mark_check.h

@@ -0,0 +1,267 @@
+/*
+
+  cpu_mark_check.h -- *Full Library* Header File for Inline CPU Profiling
+
+  See the end of this file for an example.
+
+  Public Functions:
+
+  i32 cpu_mark_new(const c8 *description);
+  void cpu_mark_check(i32 index, i32 limit);
+  void cpu_mark_new_description(i32 index, const c8 *description);
+  void cpu_mark_reset(i32 index);
+  void cpu_mark_remove(i32 index);
+
+*/
+
+#ifndef CPU_MARK_CHECK_H_Minaswan	/* Prevents multiple inclusions	*/
+#define CPU_MARK_CHECK_H_Minaswan
+  #define CPU_MARK_CHECK_VERSION	"0.1.0"
+  #ifndef TYPEDEFS_H_Minaswan		/* Header guard for typedefs.h	*/
+    #define TYPEDEFS_H_Minaswan
+    #include <stdint.h>
+    typedef uint8_t b8;			/* Booleans */
+    typedef uint16_t b16;
+    typedef uint32_t b32;
+    typedef uint64_t b64;
+
+    typedef char c8;                    /* Characters */
+    typedef unsigned char uc8;
+
+    typedef uint8_t u8;                 /* Unsigned Numbers */
+    typedef uint16_t u16;
+    typedef uint32_t u32;
+    typedef uint64_t u64;
+
+    typedef int8_t i8;                  /* Signed Numbers */
+    typedef int16_t i16;
+    typedef int32_t i32;
+    typedef int64_t i64;
+
+    typedef float f32;                  /* Floating Point Numbers */
+    typedef double f64;
+  #endif				/* TYPEDEFS_H_Minaswan */
+
+  /* Public Functions */
+  i32 cpu_mark_new(const c8 *description);
+  void cpu_mark_check(i32 index, i32 limit);
+  void cpu_mark_new_description(i32 index, const c8 *description);
+  void cpu_mark_reset(i32 index);
+  void cpu_mark_remove(i32 index);
+
+  #ifdef CPU_MARK_CHECK_IMPLEMENTATION
+    #include <stdio.h>
+    #include <stdlib.h>
+    #include <string.h>
+    #include <time.h>
+    #include <sys/time.h>
+
+    #ifndef FALSE
+      #define FALSE                       0
+    #endif
+
+    #ifndef TRUE
+      #define TRUE                        1
+    #endif
+
+    #ifndef NULL
+      #define NULL                        ((void *) 0)
+    #endif
+
+    #define CPU_MARK_DEFAULT_USEC		1000
+
+    struct cpu_mark_time {
+      i32      index;
+      u64      threshold;
+      const c8 *description;
+      struct   timeval last;
+      struct   cpu_mark_time *next;
+    };
+
+    struct cpu_mark_time *cpu_mark_list = NULL;
+
+    i32 cpu_mark_next_index(void)
+    {
+      struct cpu_mark_time *cpu_mark = NULL;
+      i32 index = 0;
+
+      for(cpu_mark = cpu_mark_list; cpu_mark; cpu_mark = cpu_mark->next) {
+        if(cpu_mark->index >= index)
+          index = cpu_mark->index;
+      }
+      index++;
+
+      return(index);
+    }
+
+    i32 cpu_mark_new(const c8 *description)
+    {
+      struct cpu_mark_time *cpu_mark = NULL;
+
+      cpu_mark = (struct cpu_mark_time *)calloc(1, sizeof(struct cpu_mark_time));
+      cpu_mark->index = cpu_mark_next_index();
+      if(description && *description)
+        cpu_mark->description = description;
+      else
+        cpu_mark->description = "No Description";
+      cpu_mark->next = cpu_mark_list;
+      cpu_mark_list = cpu_mark;
+      gettimeofday(&cpu_mark->last, (struct timezone *) 0);
+
+      return(cpu_mark->index);
+    }
+
+    void cpu_mark_remove(i32 index)
+    {
+      struct cpu_mark_time *cpu_mark = NULL, *next_cpu_mark = NULL;
+
+      if(cpu_mark_list && cpu_mark_list->index == index) {
+        cpu_mark = cpu_mark_list;
+        cpu_mark_list = cpu_mark->next;
+        free(cpu_mark);
+      } else if(cpu_mark_list) {
+        for(cpu_mark = cpu_mark_list; cpu_mark; cpu_mark = cpu_mark->next) {
+          if(cpu_mark->next && cpu_mark->next->index == index) {
+            next_cpu_mark = cpu_mark->next;
+            cpu_mark->next = next_cpu_mark->next;
+            free(next_cpu_mark);
+          }
+        }
+      }
+    }
+
+    void cpu_mark_reset(i32 index)
+    {
+      struct cpu_mark_time *cpu_mark = NULL;
+
+      for(cpu_mark = cpu_mark_list; cpu_mark; cpu_mark = cpu_mark->next) {
+        if(cpu_mark->index == index) {
+          gettimeofday(&cpu_mark->last, (struct timezone *) 0);
+        }
+      }
+    }
+
+    struct cpu_mark_time *cpu_mark_find_by_index(i32 index)
+    {
+      struct cpu_mark_time *cpu_mark = NULL;
+
+      for(cpu_mark = cpu_mark_list; cpu_mark; cpu_mark = cpu_mark->next) {
+        if(cpu_mark->index == index)
+          return(cpu_mark);
+      }
+
+      return(NULL);
+    }
+
+    void cpu_mark_new_description(i32 index, const c8 *description)
+    {
+      struct cpu_mark_time *cpu_mark = NULL;
+
+      cpu_mark = cpu_mark_find_by_index(index);
+
+      if(cpu_mark) {
+        if(description && *description)
+          cpu_mark->description = description;
+        else
+          cpu_mark->description = "No Description";
+      }
+    }
+
+    struct timeval cpu_mark_subtract_time(struct timeval *time1, struct timeval *time2)
+    {
+      struct timeval difference, no_time;
+
+      no_time.tv_sec = 0;
+      no_time.tv_usec = 0;
+
+      if(time1->tv_sec < time2->tv_sec)
+        return no_time;
+      else if(time1->tv_sec == time2->tv_sec) {
+        if(time1->tv_usec < time2->tv_usec)
+          return no_time;
+        else {
+          difference.tv_sec = 0;
+          difference.tv_usec = time1->tv_usec - time2->tv_usec;
+          return difference;
+        }
+      } else {
+        difference.tv_sec = time1->tv_sec - time2->tv_sec;
+        if(time1->tv_usec < time2->tv_usec) {
+          difference.tv_usec = time1->tv_usec + 1000000 - time2->tv_usec;
+          difference.tv_sec--;
+        } else
+          difference.tv_usec = time1->tv_usec - time2->tv_usec;
+        return difference;
+      }
+      return no_time;
+    }
+
+    void cpu_mark_check(i32 index, i32 limit)
+    {
+      struct cpu_mark_time *cpu_mark = cpu_mark_find_by_index(index);
+      struct timeval current, spent;
+      c8 local_buf[1024];
+      c8 local_buf2[1024];
+
+      if(!cpu_mark)
+        return;
+
+      gettimeofday(&current, (struct timezone *) 0);
+      spent = cpu_mark_subtract_time(&current, &cpu_mark->last);
+      if(spent.tv_sec || spent.tv_usec > limit) {
+        sprintf(local_buf2, "CPU Threshold (%d): ", cpu_mark->index);
+        strcat(local_buf2, cpu_mark->description);
+        printf("%s\r\n", local_buf2);
+        sprintf(local_buf2, "CPU Threshold (%d): ", cpu_mark->index);
+        if(spent.tv_sec) {
+          sprintf(local_buf, " secs = %ld", spent.tv_sec);
+          strcat(local_buf2, local_buf);
+        }
+        if(spent.tv_usec) {
+          sprintf(local_buf, " usecs = %ld", spent.tv_usec);
+          strcat(local_buf2, local_buf);
+        }
+        printf("%s\r\n", local_buf2);
+      }
+    }
+  #endif /* CPU_MARK_CHECK_IMPLEMENTATION */
+#endif /* CPU_MARK_CHECK_H_Minaswan */
+
+/*
+  Example:
+
+  #define CPU_MARK_CHECK_IMPLEMENTATION
+  #include "cpu_mark_check.h"
+
+  i32 mark1 = cpu_mark_new("Startup");
+
+  i32 i = 0, j = 0, k = 0;
+  for(i = 0; i < 100000; i++)	// Perform "startup" work
+    j += i;
+  k += j;
+  printf("k = %d\n", k);	// So compiler won't optimize out testing
+  cpu_mark_check(mark1, 0);	// If it's been more than 0 msec print mark time
+
+  cpu_mark_reset(mark1);	// Reset counter to start "main" work
+  // Could also just create new if we wanted "startup" to keep going
+  // i32 mark2 = cpu_mark_new("Main Working");
+
+  cpu_mark_new_description(mark1, "Main Working");
+  j = 0;
+  for(i = 0; i < 100000; i++)	// Perform "main" work
+    j += i;
+  k += j;
+  printf("k = %d\n", k);
+  cpu_mark_check(mark1, 0);	// If it's been more than 0 msec print mark time
+
+  cpu_mark_new_description(mark1, "Main Still Working");
+  j = 0;
+  for(i = 0; i < 100000; i++)	// Perform more "main" work
+    j += i;
+  k += j;
+  printf("k = %d\n", k);
+  cpu_mark_check(mark1, 0);	// If it's been more than 0 msec print mark time
+
+  cpu_mark_remove(mark1);
+
+*/

data/lib/data/libsrc/defines.h

@@ -0,0 +1,29 @@
+/*
+   defines.h -- Basic C preprocessor macro definitions
+*/
+
+#ifndef DEFINES_H_Minaswan	/* Header guard to prevent multiple inclusions */
+  #define DEFINES_H_Minaswan
+  #define DEFINES_VERSION	"0.1.0"
+  #ifndef NULL
+    #define NULL		((void *) 0)
+  #endif
+  #ifndef FALSE
+    #define FALSE		0
+  #endif
+  #ifndef TRUE
+    #define TRUE		1
+  #endif
+  #ifndef NO
+    #define NO			0
+  #endif
+  #ifndef YES
+    #define YES			1
+  #endif
+  #ifndef OFF
+    #define OFF			0
+  #endif
+  #ifndef ON
+    #define ON			1
+  #endif
+#endif /* DEFINES_H_Minaswan */