Fixing render.

render-test.cpp

@@ -0,0 +1,73 @@
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+
+#include "render.h"
+#include "terminal.h"
+
+/* Log level guideline:
+ * - ZF_LOG_FATAL - happened something impossible and absolutely unexpected.
+ *   Process can't continue and must be terminated.
+ *   Example: division by zero, unexpected modifications from other thread.
+ * - ZF_LOG_ERROR - happened something possible, but highly unexpected. The
+ *   process is able to recover and continue execution.
+ *   Example: out of memory (could also be FATAL if not handled properly).
+ * - ZF_LOG_WARN - happened something that *usually* should not happen and
+ *   significantly changes application behavior for some period of time.
+ *   Example: configuration file not found, auth error.
+ * - ZF_LOG_INFO - happened significant life cycle event or major state
+ *   transition.
+ *   Example: app started, user logged in.
+ * - ZF_LOG_DEBUG - minimal set of events that could help to reconstruct the
+ *   execution path. Usually disabled in release builds.
+ * - ZF_LOG_VERBOSE - all other events. Usually disabled in release builds.
+ *
+ * *Ideally*, log file of debugged, well tested, production ready application
+ * should be empty or very small. Choosing a right log level is as important as
+ * providing short and self descriptive log message.
+ */
+/*
+#define ZF_LOG_VERBOSE 1
+#define ZF_LOG_DEBUG   2
+#define ZF_LOG_INFO    3
+#define ZF_LOG_WARN    4
+#define ZF_LOG_ERROR   5
+#define ZF_LOG_FATAL   6
+*/
+
+// LOGGING with file output
+#include "zf_log.h"
+
+FILE *g_log_file;
+
+static void file_output_callback(const zf_log_message *msg, void *arg) {
+  (void)arg;
+  *msg->p = '\n';
+  fwrite(msg->buf, msg->p - msg->buf + 1, 1, g_log_file);
+  fflush(g_log_file);
+}
+
+static void file_output_close(void) { fclose(g_log_file); }
+
+static void file_output_open(const char *const log_path) {
+  g_log_file = fopen(log_path, "a");
+  if (!g_log_file) {
+    ZF_LOGW("Failed to open log file %s", log_path);
+    return;
+  }
+  atexit(file_output_close);
+  zf_log_set_output_v(ZF_LOG_PUT_STD, 0, file_output_callback);
+}
+
+struct console_details console;
+
+int main(int argc, char *argv[]) {
+
+  file_output_open("render.log");
+
+  render(1, "^P2HELLO^P3 THERE^P2\n", 22);
+  render(1, "^P2^Fbat.^P1\n^P1OK.\n", 21);
+
+
+return 0;
+}

render.cpp

@@ -1,15 +1,14 @@
-#include <unistd.h> // usleep
+#include <ctype.h>
 #include <stdio.h>
-#include <time.h>
 #include <string.h>
-#include <ctype.h>
+#include <time.h>
+#include <unistd.h> // usleep
 
 #include "render.h"
 #include "terminal.h"
 #include "zf_log.h"
 
-extern const char *strnstr(const char *source, int len, const char *needle);
-extern const char *repr(const char *data);
+#include "utils.h"
 extern struct console_details console;
 
 struct render current_render;
@@ -41,7 +40,6 @@ void render_sleep(void) {
   }
 }
 
-
 /*
 Well SNAP!  Mystic numbers don't remotely match ANSI color codes.
 
@@ -448,7 +446,7 @@ void render(int fd, const char *string_out, int len) {
   // Check our time from time to time.
   // If we start running long, disable sleeps.
 
-  while ((trigger = strnstr(cp, len - (cp - trigger), TRIGGER)) != NULL) {
+  while ((trigger = strnstr(cp, len - (cp - string_out), TRIGGER)) != NULL) {
     // There is special things to handle in here.
     while (cp != trigger) {
       elapsed = time(NULL) - start;
@@ -462,15 +460,17 @@ void render(int fd, const char *string_out, int len) {
       cp++;
     };
 
-    // ZF_LOGI( "at trigger: (%s)", cp);
+    ZF_LOGI("at trigger: (%s)", cp);
     cp += strlen(TRIGGER);
 
     // Ok, we're pointing at the trigger -- do something.
     cp = process_trigger(fd, cp);
 
-    // ZF_LOGI( "after trigger: (%s)", cp);
+    ZF_LOGI("after trigger: (%s)", cp);
   };
 
+  ZF_LOGI("no more triggers, finish it up: (%s)", cp);
+
   // We still might be under a rendering effect.
   while (cp < (string_out + len)) {
     elapsed = time(NULL) - start;

utils.cpp

@@ -0,0 +1,127 @@
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+
+#include "utils.h"
+
+// http://c-faq.com/lib/randrange.html
+int randint(int N) { return rand() / (RAND_MAX / N + 1); }
+
+// http://c-faq.com/lib/randrange.html
+// numbers in the range [M, N] could be generated with something like
+
+int randrange(int M, int N) {
+  return M + rand() / (RAND_MAX / (N - M + 1) + 1);
+}
+
+/**
+ * Display a repr of the given string.
+ *
+ * This converts most \n\r\v\f\t codes,
+ * defaults to \xHH (hex value).
+ */
+char *repr(const char *data) {
+  static char buffer[40960];
+  char *cp;
+
+  strcpy(buffer, data);
+  cp = buffer;
+  while (*cp != 0) {
+    char c = *cp;
+
+    if (c == ' ') {
+      cp++;
+      continue;
+    };
+    /* Ok, it's form-feed ('\f'), newline ('\n'), carriage return ('\r'),
+     * horizontal tab ('\t'), and vertical tab ('\v') */
+    if (strchr("\f\n\r\t\v\?", c) != NULL) {
+      memmove(cp + 1, cp, strlen(cp) + 1);
+      *cp = '\\';
+      cp++;
+      switch (c) {
+      case '\f':
+        *cp = 'f';
+        cp++;
+        break;
+      case '\n':
+        *cp = 'n';
+        cp++;
+        break;
+      case '\r':
+        *cp = 'r';
+        cp++;
+        break;
+      case '\t':
+        *cp = 't';
+        cp++;
+        break;
+      case '\v':
+        *cp = 'v';
+        cp++;
+        break;
+      default:
+        *cp = '?';
+        cp++;
+        break;
+      }
+      continue;
+    }
+
+    if (c == '\\') {
+      memmove(cp + 1, cp, strlen(cp) + 1);
+      *cp = '\\';
+      cp += 2;
+      continue;
+    }
+    if (c == '"') {
+      memmove(cp + 1, cp, strlen(cp) + 1);
+      *cp = '\\';
+      cp += 2;
+      continue;
+    }
+    if (strchr("[()]{}:;,.<>?!@#$%^&*", c) != NULL) {
+      cp++;
+      continue;
+    }
+    if (strchr("0123456789", c) != NULL) {
+      cp++;
+      continue;
+    }
+    if (strchr("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ", c) !=
+        NULL) {
+      cp++;
+      continue;
+    }
+
+    // Ok, default to \xHH output.
+    memmove(cp + 3, cp, strlen(cp) + 1);
+    char buffer[10];
+    sprintf(buffer, "\\x%02x", (int)c & 0xff);
+    strncpy(cp, buffer, 4);
+    cp += 4;
+    continue;
+  }
+
+  return buffer;
+}
+
+/*
+ * strnstr()
+ *
+ * buffer safe version that looks for a string.
+ */
+const char *strnstr(const char *source, int len, const char *needle) {
+  int pos;
+
+  for (pos = 0; pos < len; pos++) {
+    if (source[pos] == needle[0]) {
+      if (strncmp(source + pos, needle, strlen(needle)) == 0) {
+        return source + pos;
+      }
+    }
+  }
+  return NULL;
+}
+
+

utils.h

@@ -0,0 +1,22 @@
+#ifndef UTILS_H
+#define UTILS_H
+
+// http://c-faq.com/lib/randrange.html
+int randint(int N);
+
+// http://c-faq.com/lib/randrange.html
+// numbers in the range [M, N] could be generated with something like
+
+int randrange(int M, int N);
+
+/**
+ * Display a repr of the given string.
+ *
+ * This converts most \n\r\v\f\t codes,
+ * defaults to \xHH (hex value).
+ */
+char *repr(const char *data);
+const char *strnstr(const char *source, int len, const char *needle);
+
+#endif
+