Working c++ buffer. Broke things.

Moved/BROKE the main mangle/wrangle into wordplay.
Updated the main routines mangle() and
console() to take std::string.

We're back working (as in you can login),
but the mangle, etc, needs to be updated
still.

I'm trying to use C++ 17 here.  If the
compiler fails with string.reserve()
and cxx-11 by the message, try this:

delete the CMakeCache.txt file, and re-run

    cmake .

That should tell it to redo up the build files,
and it should enable C++ 17 in gcc.

Using play.assign(), I'm able to reserve a
large buffer, and keep it!

CMakeLists.txt

@@ -26,12 +26,14 @@ set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -D_GLIBCXX_DEBUG")
 ###########
 # set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-deprecated-declarations")
 
+# rm CMakeCache.txt and cmake .   if you change any of the C++ Standards.
 
 ##############
 # C++ Standard
 ##############
-set(CMAKE_CXX_STANDARD   14)
-set(CMAKE_CXX_EXTENSIONS OFF)
+## set(CMAKE_CXX_STANDARD   14)
+set(CMAKE_CXX_STANDARD   17)
+set(CMAKE_CXX_EXTENSIONS ON)
 
 
 # Enable testing
@@ -86,10 +88,11 @@ add_subdirectory(zf_log)
 # )
 # add_executable(yourProj ${SOURCES})
 
-add_executable(hharry hharry.cpp lastseen.cpp terminal.cpp render.cpp utils.cpp images.h)
+add_executable(hharry hharry.cpp lastseen.cpp terminal.cpp render.cpp utils.cpp images.h wordplay.cpp)
 target_link_libraries(hharry util)
 target_link_libraries(hharry zf_log)
-target_compile_definitions(hharry PUBLIC ZF_LOG_DEF_LEVEL=ZF_LOG_INFO)
+# target_compile_definitions(hharry PUBLIC ZF_LOG_DEF_LEVEL=ZF_LOG_INFO)
+target_compile_definitions(hharry PUBLIC ZF_LOG_DEF_LEVEL=ZF_LOG_VERBOSE)
 
 add_executable(try-re try-re.c)
 

hharry.cpp

@@ -7,6 +7,9 @@
 #include <termios.h>
 #include <unistd.h>
 
+#include <string>
+using namespace std;
+
 // #include <signal.h> // handle Ctrl-C/SIGINT
 
 #include <strings.h> // strcasecmp
@@ -15,7 +18,6 @@
 #include <ctype.h>
 #include <stdlib.h> // random()
 
-#include <regex.h>
 
 /* Log level guideline:
  * - ZF_LOG_FATAL - happened something impossible and absolutely unexpected.
@@ -48,7 +50,9 @@
 */
 
 // When debugging low-level, use this:
-// ZF_LOG_LEVEL=ZF_LOG_VERBOSE
+// #define ZF_LOG_LEVEL ZF_LOG_VERBOSE
+// Except this doesn't work.  It needs to be anywere the 
+// zf_log.h is included.
 
 // LOGGING with file output
 #include "zf_log.h"
@@ -64,29 +68,29 @@ static void file_output_callback(const zf_log_message *msg, void *arg) {
 
 static void file_output_close(void) { fclose(g_log_file); }
 
-static void file_output_open(const char *const log_path) {
+static int 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;
+    return 0;
   }
   atexit(file_output_close);
   zf_log_set_output_v(ZF_LOG_PUT_STD, 0, file_output_callback);
+  return 1;
 }
 
-// END LOGGING
+void log_flush(void) {
+  fflush(g_log_file);
+}
 
-#include <string>
-using namespace std;
+// END LOGGING
 
+#include "utils.h"
 #include "terminal.h"
 
 struct console_details console;
 
-#include "images.h"
-#include "lastseen.h"
-#include "render.h"
-#include "utils.h"
+#include "wordplay.h"
 
 /*
 What is the name of the actual, real Mystic executable
@@ -104,75 +108,6 @@ that we'll be executing and mangling?
 
  */
 
-#ifdef CPP_MADMAN_STL_CODE
-
-const char *random_phrase(const char *words, int len, int last_seen) {
-  // ooh.  a map of char *s to last_seen_events.  :P
-  static map<const char *, array<int>> tracker;
-  map<const char *, array<int>>::iterator it;
-  array<int, last_seen> it = tracker.find(words);
-  if (it == tracker.end()) {
-    // key does not exist.
-    array<int, last_seen> last;
-    for (int i = 0; i < last_seen; i++) {
-      last[i] = -1;
-    };
-
-    tracker.insert(words, last);
-    it = tracker.find(words);
-  };
-}
-#endif
-
-void harry_idle_event(int fd) {
-  // Make something happen
-  char buffer[100];
-  int slen;
-  int r;
-  // This is no where near finished, BUT!
-  const char *phrases[] = {"Hahaha",    "Snicker, snicker", "Boo!",
-                           "MeOW",      "I see U",          "Arrooo!",
-                           "Ahh-wooo!", "Aaaooo!"};
-  const char *cp;
-  static LastSeen last_seen_harry_event(2);
-
-  // Remember the last phrase used,
-  // and don't repeat (the last two)!
-
-  do {
-    r = randint((sizeof(phrases) / sizeof(char *)));
-    // r = random() % ((sizeof(phrases) / sizeof(char *)) - 1);
-  } while (last_seen_harry_event.seen_before(r));
-
-  // ZF_LOGD("%d => %d %d", r, last_seen_harry_event[0],
-  // last_seen_harry_event[1]);
-
-  cp = phrases[r];
-  int color = random() % 15 + 1;
-  /*
-  int color = random() % 16;
-  if (color == 0) {
-    color++;
-  } // If it's 0 let's make it 1.   // color = (random() % 15) + 1
-  */
-
-  slen = snprintf(buffer, sizeof(buffer), "^S2^C%02d%s^P2^CR^D%02d", color, cp,
-                  (int)strlen(cp));
-  if (slen >= sizeof(buffer)) {
-    ZF_LOGE("snprintf %d > size %d", slen, (int)sizeof(buffer));
-    buffer[0] = 0;
-  }
-  ZF_LOGD("harry_event: render(%d, \"%s\")", fd, buffer);
-  render(fd, buffer, strlen(buffer));
-}
-
-void init_harry() {
-  // init_have_seen(last_seen_harry_event, MAX_HARRY_EVENT_DUPS);
-  // ZF_LOGD("init => %d %d", last_seen_harry_event[0],
-  // last_seen_harry_event[1]);
-  console_init(&console);
-}
-
 /*
 The code to get the username and fullname is useless on telnet
 connections.
@@ -214,616 +149,6 @@ int locate_user(const char *alias) {
 
 // Buffers are BSIZE + 1, so a buffer that size can strcpy safely.
 
-regex_t ANSI;
-regex_t WORDS;
-regex_t WORD;
-
-int init_regex(void) {
-  int ret;
-  char ansi[] = "\x1b\[[0-9]+(;[0-9]+)*?[a-zA-Z]";
-  char words[] = "[a-zA-Z]+( [a-zA-Z]+)+";
-  char word[] = "[a-zA-Z]+";
-  char errorbuf[100];
-
-  if (ret = regcomp(&ANSI, ansi, REG_EXTENDED | REG_NEWLINE)) {
-    regerror(ret, &ANSI, errorbuf, sizeof(errorbuf));
-    ZF_LOGW("Regex %s failed to compile: %s", ansi, errorbuf);
-    return 0;
-  };
-
-  if (ret = regcomp(&WORDS, words, REG_EXTENDED | REG_NEWLINE)) {
-    regerror(ret, &WORDS, errorbuf, sizeof(errorbuf));
-    ZF_LOGW("Regex %s failed to compile: %s", words, errorbuf);
-    return 0;
-  };
-
-  if (ret = regcomp(&WORD, word, REG_EXTENDED | REG_NEWLINE)) {
-    regerror(ret, &WORD, errorbuf, sizeof(errorbuf));
-    ZF_LOGW("Regex %s failed to compile: %s", word, errorbuf);
-    return 0;
-  };
-
-  return 1;
-}
-
-int regmatch(regex_t *preg, const char *string, size_t nmatch,
-             regmatch_t pmatch[], int eflags) {
-  // returns number of matches found.  (Max nmatch)
-  int matches = 0;
-  int offset = 0;
-
-  while (matches < nmatch) {
-    int ret = regexec(preg, string + offset, nmatch - matches, pmatch + matches,
-                      eflags);
-    if (!ret) {
-      int current = offset;
-      offset += pmatch[matches].rm_eo;
-      pmatch[matches].rm_so += current;
-      pmatch[matches].rm_eo += current;
-      matches++;
-    } else if (ret == REG_NOMATCH) {
-      break;
-    } else {
-      break;
-    }
-  }
-  return matches;
-}
-
-#define MAX_MATCH 32
-regmatch_t rxmatch[MAX_MATCH];
-
-int rx_match(regex_t *regex, const char *buffer) {
-  int ret;
-
-  ret = regmatch(regex, buffer, MAX_MATCH, rxmatch, 0);
-  if (0) {
-    for (int i = 0; i < ret; i++) {
-      ZF_LOGI("%d : (%d-%d)", i, rxmatch[i].rm_so, rxmatch[i].rm_eo);
-    }
-  }
-  return ret;
-}
-
-/**
- * random_activate()
- *
- * Is a weight (1-10),
- * tests if random number is < weight * 10.
- *
- * So random_activate(9) happens more frequently
- * then random_activate(8) or lower.
- *
- * This probably needs to be fixed.
- * We need a better randint(RANGE) code.
- */
-int random_activate(int w) {
-  int r = randint(100);
-  if (r <= (w * 10)) {
-    return 1;
-  };
-  return 0;
-}
-
-/*
-  word_state():    // deprecated
-
-  -1 only lower
-  +1 only upper
-   0 mixed
-*/
-int word_state(const char *buffer, int len) {
-  int p;
-  int upper = 0;
-  int lower = 0;
-  int ret;
-  float pct;
-
-  for (p = 0; p < len; p++) {
-    char c = buffer[p];
-    if (isalpha(c)) {
-      if (isupper(c)) {
-        upper++;
-      };
-      if (islower(c)) {
-        lower++;
-      };
-    }
-  }
-
-  if (upper == lower) {
-    return 0;
-  }
-
-  if (upper > lower) {
-    ret = 1;
-    pct = ((float)lower / (float)upper) * 100.0;
-  } else {
-    ret = -1;
-    pct = ((float)upper / (float)lower) * 100.0;
-  }
-
-  // ZF_LOGD("So far %d with %f %%", ret, pct);
-
-  if (pct < 40.0) {
-    return ret;
-  }
-  return 0;
-}
-
-/*
-Given a buffer and length, mangle away.
-
-toupper, tolower, flipper
- */
-int word_mangler(char *buffer, int len) {
-  int p;
-  int count = 0;
-  int state;
-
-  // state = word_state(buffer, len);
-  // ZF_LOGD("word_state(%.*s) %d", len, buffer, state);
-  state = randrange(-1, 1);
-
-  // TODO:  Transposer
-
-  for (p = 0; p < len; p++) {
-    char c = buffer[p];
-
-    if (randint(len) == p) {
-      break;
-    }
-    switch (state) {
-    case -1:
-      // upper
-      if (islower(c)) {
-        count++;
-        buffer[p] = toupper(c);
-      }
-      break;
-    case 1:
-      // lower
-      if (isupper(c)) {
-        count++;
-        buffer[p] = tolower(c);
-      }
-      break;
-    case 0:
-      // flipper
-      if (islower(c)) {
-        count++;
-        buffer[p] = toupper(c);
-      } else {
-        if (isupper(c)) {
-          count++;
-          buffer[p] = tolower(c);
-        }
-      }
-      break;
-    }
-  }
-  return count;
-}
-
-int word_wrangler(char *buffer, int len) {
-  int p;
-  int count;
-  int state;
-
-  // state = word_state(buffer, len);
-  // ZF_LOGD("word_state(%.*s) %d", len, buffer, state);
-  if (len < 5) {
-    return 0;
-  }
-
-  p = randint(len - 4) + 2;
-
-  for (count = 0; count < 4; count++) {
-    if (!isalpha(buffer[p + count]))
-      break;
-  }
-
-  ZF_LOGV_MEM(buffer, len, "wrangler %d len %d:", p, count);
-
-  if (count >= 2) {
-    for (int x = 0; x < count / 2; x++) {
-      char ch = buffer[p + x];
-      buffer[p + x] = buffer[p + count - 1 - x];
-      buffer[p + count - 1 - x] = ch;
-    }
-    ZF_LOGV_MEM(buffer, len, "word now:");
-    return 1;
-  } else
-    return 0;
-}
-
-int buffer_insert(char *buffer, int len, int max_length, int pos,
-                  const char *insert) {
-  if (len + strlen(insert) > max_length) {
-    ZF_LOGD("buffer_insert failed [%s]", repr(insert));
-    return 0;
-  }
-  memmove(buffer + pos + strlen(insert), buffer + pos, len - pos);
-  strncpy(buffer + pos, insert, strlen(insert));
-  return 1;
-}
-
-/*
- * The buffer that we've been given is much larger now.
- *
- * We can no longer mangle or insert into the given buffer.
- * Why?  Because we don't know what is behind it now!
- */
-int mangle(int fd, const char *buffer, int len) {
-  int x, i;
-  int need_render = 0; // changing word case around doesn't need the render
-  int mangled = 0;
-  int mangled_chars = 0;
-  char play[BSIZE * 2]; // The main buffer to send.
-  const char *cp;
-
-  // Make a copy of buffer, since it can no longer be changed
-  // inserted into.
-
-  memcpy(play, buffer, len);
-
-  // NEVER reference buffer from this point on!
-
-  char work[BSIZE * 2]; // The mess with buffer.
-
-  /*
-   We use the work buffer to blank out the ANSI
-   before trying to locate words.  (So we don't
-   grab part of the ANSI codes and mangle those!)
-  */
-
-  // Use terminal - clean out ANSI
-
-  // ZF_LOGI("mangle:");
-  ZF_LOGI_MEM(play, len, "Mangle (%u bytes):", len);
-
-  // strcpy(work, buffer);
-
-  /*
-  NOTE:  We copy the buffer, so we can clear out ANSI codes, etc.
-  Otherwise we might mess some ANSI up in the manglying
-  process.
-  */
-
-  /*
-  Is there a way to track -- what I've inserted, and make it exempt from
-  other modifications / mangler, wrangler?
-   */
-
-  /*
-   (random) Look for ANSI CLS and:
-
-      display random spooky texts around, with delays ... then CLS.
-
-      display ANSI graphic file, with delays ... then CLS
-   */
-  const char *ANSI_CLS = "\x1b[2J";
-  cp = strnstr(play, len, ANSI_CLS); // strstr(buffer, ANSI_CLS);
-
-  if (cp != NULL) {
-    static int ANSI_CLS_count = 0; // count the number we've seen
-    ZF_LOGI("seen: ANSI_CLS");
-    ANSI_CLS_count++;
-
-    // Don't activate on the very first CLS.  Too soon, don't screw up the ANSI
-    // detection.
-    if (ANSI_CLS_count > 1) {
-      // Ok, figure out the restore color, just in case
-      struct console_details temp_console;
-      // Make exact copy of our current console state.
-      memcpy(&temp_console, &console, sizeof(console));
-      // Play the buffer into the console
-      console_receive(&temp_console, play, cp - play);
-      char restore_color[30]; // ansi color
-      strcpy(restore_color, color_restore(&temp_console));
-
-      if (random_activate(3)) {
-        char display[100] = "";
-        int slen;
-        int needs_cls = 0;
-
-        struct image {
-          const char **lines;
-          int size;
-          int cls;
-          int width; // height = size
-        } images[] = {{ghost, sizeof(ghost) / sizeof(char *), 1, 0},
-                      {ghead, sizeof(ghead) / sizeof(char *), 1, 0},
-                      {wolf, sizeof(wolf) / sizeof(char *), 1, 0},
-                      {panther, sizeof(panther) / sizeof(char *), 1, 0},
-                      {bat, sizeof(bat) / sizeof(char *), 1, 0},
-                      {icu, sizeof(icu) / sizeof(char *), 0, 20},
-                      {skull, sizeof(skull) / sizeof(char *), 0, 19},
-                      {skullblink, sizeof(skullblink) / sizeof(char *), 0, 19}};
-
-        static LastSeen last_files(2);
-        int r;
-
-        do {
-          r = randint((sizeof(images) / sizeof(image)));
-        } while (last_files.seen_before(r));
-
-        char fgoto[32];
-
-        if (!images[r].cls) {
-          int x = 0, y = 0;
-
-          x = randint(79 - images[r].width);
-          y = randint(24 - images[r].size);
-
-          int slen;
-          // render image, home cursor
-          slen = snprintf(fgoto, sizeof(fgoto), "^f%02d%02d\x1b[1;1H", x, y);
-          if (slen >= sizeof(fgoto)) {
-            ZF_LOGE("snprintf %d > size %d", slen, (int)sizeof(fgoto));
-            fgoto[0] = 0;
-          }
-        } else {
-          strcpy(fgoto, "^F");
-        }
-
-        // (2); // (sizeof(possibles) / sizeof(file_need)) - 1);
-        needs_cls = images[r].cls;
-
-        // I get what's happening.  Mystic moves cursor to home, CLS, cursor
-        // home. When we get here, we're ALWAYS at the top of the screen...
-        // Hence our bat isn't displayed at the end of the screen.
-
-        // This is before the actual CLS, so we CLS before displaying our files.
-        // I tried a ^P2 before doing this .. but I'd rather have the picture up
-        // right away I think.
-
-        // Ok, yes, there's no filename being sent.  :P
-        render_image(images[r].lines, images[r].size);
-
-        slen = snprintf(display, sizeof(display), "%s%s%s^P3",
-                        needs_cls ? "\x1b[2J" : "", fgoto, restore_color);
-        if (slen >= sizeof(display)) {
-          ZF_LOGE("snprintf %d > size %d", slen, (int)sizeof(display));
-          display[0] = 0;
-        }
-        ZF_LOGI("mangle(ANSI_CLS): %d file inserted %s", r, repr(display));
-
-        // Move the buffer so there's room for the display string.
-        if (buffer_insert(play, len, sizeof(play), cp - play, display)) {
-          len += strlen(display);
-          // if (string_insert(buffer, 1024, cp - buffer, display)) {
-
-          ZF_LOGI_MEM(play, len, "mangle(ANSI_CLS) (%u bytes):", len);
-          // ZF_LOGI("mangle(ANSI_CLS):");
-          // ZF_LOGI_REPR(buffer);
-          // ZF_LOGI("mangle(ANSI_CLS): [%s]", repr(buffer));
-          need_render = 1;
-
-          /*
-          Copy the new buffer over, but hide our "render" code
-          from the remaining mangler steps.
-          */
-          memcpy(work, play, len);
-          // strcpy(work, buffer);
-          i = cp - play;
-          // find offset into "buffer"
-          // apply to work.
-          memset(work + i, ' ', strlen(display));
-
-        } else {
-          ZF_LOGD("insert failed [%s].", repr(display));
-        }
-      } else {
-        if (random_activate(4)) {
-          int r;
-          char display[100] = "";
-          int slen;
-
-          /*
-          Interesting note here:
-          "Anyone there" qualifies as a valid WORDS regex match.
-          It is possible that it can get mangled/wrangled!
-          */
-          const char *phrasing[] = {
-              "^R1Haha^P1ha^P1ha", "Poof!", "Got U", "Anyone there?",
-              "^R1Knock, ^P1Knock",
-              /*
-              This picks random color and position -- then
-              homes cursor and changes to another color.  (This can be seen.)
-               */
-              "^G0101^C07^S9Segmentation fault (core dumped)^P2"};
-          static LastSeen last_phrasing(2);
-
-          ZF_LOGI("mangle(ANSI_CLS)");
-          // sprintf( display, "^P2...");
-          // This string actually screws up ANSI detection (takes too long)
-          // strcpy(display, "^P2^S501234567890^P1abcdef^P2g^P3h^P4i^S0^P2");
-
-          // strcpy(display, "^P2^S301234^P15^S0^P2");
-
-          // Add in random text, plus color!
-          do {
-            r = randint(sizeof(phrasing) / sizeof(char *));
-          } while (last_phrasing.seen_before(r));
-
-          int color = random() % 15 + 1;
-          int x = random() % 30 + 1;
-          int y = random() % 15 + 1;
-
-          /*
-          Don't have it pause there before moving the cursor.
-
-          Move the cursor, get the color changed, THEN pause.
-          Then act all crazy.
-
-          NOTE:  Make sure if you use any ^R Render effects, turn them off
-          before trying to display the restore_color.  :P   ^R0 Also, make
-          sure you re-home the cursor ^G0101 because that's where they are
-          expecting the cursor to be!  (At least it's how Mystic does it.)
-
-          HOME, CLS, HOME, ...  Not sure what others do there.  We'll see.
-          */
-
-          slen = snprintf(display, sizeof(display),
-                          "^G%02d%02d^S3^C%02d^P1%s^S0^R0%s^P1^G0101", x, y,
-                          color, phrasing[r], restore_color);
-          if (slen >= sizeof(display)) {
-            ZF_LOGE("snprintf %d > size %d (Phrase: %d, %s)", slen,
-                    (int)sizeof(display), r, phrasing[r]);
-            display[0] = 0;
-          }
-
-          // sprintf(display, "^P1^S3^C%02d%s^S0^R0%s^P1", color, phrasing[r],
-          // restore_color);
-          // Added debug statement so we can identify what was sent... color,
-          // number picked and what that is
-          ZF_LOGD("mangle(ANSI_CLS): Inserted color=%02d r=%d phrase='%s'",
-                  color, r, phrasing[r]);
-          ZF_LOGI_MEM(play, len, "mangle(ANSI_CLS) :");
-
-          // Move the buffer so there's room for the display string.
-          if (buffer_insert(play, len, sizeof(play), cp - play, display)) {
-            len += strlen(display);
-
-            // if (string_insert(buffer, BSIZE * 4, cp - buffer, display)) {
-            ZF_LOGI_MEM(play, len, "mangle(ANSI_CLS) + :");
-            // ZF_LOGI("mangle(ANSI_CLS):");
-            // ZF_LOGI_REPR(buffer);
-            need_render = 1;
-
-            /*
-            Copy the new buffer over, but hide our "render" code
-            from the remaining mangler steps.
-            */
-            memcpy(work, play, len);
-            // strcpy(work, buffer);
-            i = cp - play;
-            // find offset into "buffer"
-            // apply to work.
-            memset(work + i, ' ', strlen(display));
-
-          } else {
-            ZF_LOGD("insert failed [%s].", repr(display));
-          }
-        }
-      }
-    }
-  }
-
-  memcpy(work, play, len);
-
-  // strcpy(work, buffer); // sure.
-
-  // NOTE: This is NOT aware of my ^TRIGGERS, so they will show up
-  // as valid things to mangle in work.  (Keep this in mind).
-
-  const char replace_with = ' ';
-  for (x = 0; x < len; x++) {
-    termchar tc = console_char(&console, play[x]);
-    int ansi = tc.in_ansi;
-
-    if (ansi) {
-      work[x] = replace_with;
-      if (tc.ansi != START) {
-        ZF_LOGD("ANSI type %d at %d", tc.ansi, x);
-      }
-    }
-    // fixup "work" so it's a valid C string
-    if (buffer[x] == 0) {
-      work[x] = replace_with;
-    }
-  }
-  // fixup "work" buffer so it's a valid c string
-  // (required for regex to work.)
-  work[len] = 0;
-
-  ZF_LOGV_MEM(work, len, "Work now:");
-
-  /*
-   (random) Locate words (in work), and possibly flip them around.
-   Transpose words.  Transpose case.  Transpose letters.
-
-   Ok, what would be interesting, is if we could find
-   W\x1[0;34mORDS with color changes in them, and work with them.
-   without screwing up the color changes, of course.  :P
-
-  Example:
-
-   Y\x1b[0;1mes \x1b[0;1;34m\x1b[0;1;34;44m N\x1b[0;1;44mo
-   Yes No
-   ^ This would be a job for a crazy regex.
-
-   I'd have to map the characters to positions in the buffer.  :S
-   I'd want mangle and wrangle to work.
-
-   The Message menu -- doesn't hardly get mangled at all (at least on
-   my test site).  Because all of the color changes break up the
-   words in the menu.
-   */
-  x = rx_match(&WORDS, work);
-  ZF_LOGD("found %d word groups", x);
-
-  if (x > 0) {
-    for (i = 0; i < x; i++) {
-
-      // Yes!  Be random!
-      if (random_activate(8)) {
-        int c = word_mangler(play + rxmatch[i].rm_so,
-                             rxmatch[i].rm_eo - rxmatch[i].rm_so);
-        if (c) {
-          mangled++;
-          mangled_chars += c;
-        }
-      }
-
-      if (random_activate(4)) {
-        word_wrangler(play + rxmatch[i].rm_so,
-                      rxmatch[i].rm_eo - rxmatch[i].rm_so);
-      }
-    }
-  }
-
-  /*
-   (random) Locate single words, and transpose words.
-   Transpose letters.
-   */
-
-  /*
-   (random) Display up to certain point.  Delay.
-   Print some characters slowly.  Delay.
-   */
-
-  if (mangled)
-    ZF_LOGI("Mangled %d word, %d chars (render %d)", mangled, mangled_chars,
-            need_render);
-
-  if (need_render) {
-    ZF_LOGD_MEM(play, len, "Ready to render:");
-    // ZF_LOGD("HH %d : (%d) %s", need_render, (int)strlen(buffer),
-    // repr(buffer));
-  }
-
-  if (need_render) {
-    render(fd, play, len);
-  } else {
-    write(fd, play, len);
-  };
-  return need_render && mangled;
-}
-
-int harry_happens(time_t *last_event, int wakeup) {
-  time_t now = time(NULL);
-  int elapsed = now - *last_event;
-
-  if (elapsed > wakeup) {
-    // Ok!  It's been too long since we've done something.
-    *last_event = now;
-    return 1;
-  }
-  return 0;
-}
-
 /*
 
 This is done.  :D  My buffering system works with stack'em.
@@ -898,12 +223,15 @@ ZModem:
 
  */
 
+// TODO:  Get everything above this -- into another file.
+
 int main(int argc, char *argv[]) {
   int master;
   pid_t pid;
   int node = -1;
 
-  file_output_open("horrible_harry.log");
+  if (!file_output_open("horrible_harry.log"))
+    return 2;
   init_harry();
 
   srandom(time(NULL));
@@ -960,12 +288,17 @@ int main(int argc, char *argv[]) {
     char *args[20]; // max 20 args
     int x;
     char new_exec[] = TARGET;
+
+    // build new args list
     args[0] = new_exec;
 
     for (x = 1; x < argc; x++) {
       args[x] = argv[x];
     };
+
+    // null term the list
     args[x] = NULL;
+
     // run Mystic, run!
     execvp(TARGET, args);
   }
@@ -996,8 +329,16 @@ int main(int argc, char *argv[]) {
     // https://viewsourcecode.org/snaptoken/kilo/02.enteringRawMode.html
     tcsetattr(1, TCSAFLUSH, &tios);
 
-    char buffer[BSIZE + 1];
-    int size = 0;
+    /*
+    This doesn't need to be static -- because it is part of
+    main.  Once main ends, we're done.
+    */
+    string buffer;
+    buffer.reserve(BSIZE * 2);
+    string play;
+    play.reserve(4096);
+
+    // int size = 0;  // use buffer.size() instead
 
     for (;;) {
       int time_idle;
@@ -1028,7 +369,7 @@ int main(int argc, char *argv[]) {
        And as we get closer, 15-25 seconds.
       */
 
-      if (size == 0) {
+      if (buffer.size() == 0) {
         // buffer is empty
         timeout.tv_sec = randrange(10, 20);
         timeout.tv_usec = 0;
@@ -1046,43 +387,83 @@ int main(int argc, char *argv[]) {
         if (time_idle) {
           harry_idle_event(STDOUT_FILENO);
         } else {
+          /*
           if (ZF_LOG_ON_VERBOSE) {
             ZF_LOGV_MEM(buffer, size, "TIMEOUT buffer size=%d", size);
           } else {
-            ZF_LOGI("TIMEOUT buffer size=%d", size);
-          }
-          console_receive(&console, buffer, size);
-          write(STDOUT_FILENO, buffer, size);
-          size = 0;
+            */
+          ZF_LOGI_MEM(buffer.data(), buffer.size(), "TIMEOUT buffer size=%lu", buffer.size());            
+          // ZF_LOGI("TIMEOUT buffer size=%lu", buffer.size());
+          // }
+          // console_receive(&console, buffer, size);
+          ZF_LOGI("console_string");
+          console_string(&console, buffer);
+          // write(STDOUT_FILENO, buffer, size);
+          ZF_LOGI("write buffer");
+          write(STDOUT_FILENO, buffer.data(), buffer.size());
+          ZF_LOGI("buffer clear");
+          buffer.clear();
+          // size = 0;
           // buffer is empty now
         }
       }
 
-      int total;
-
       // read_fd esta atribuido com read_fd?
       if (FD_ISSET(master, &read_fd)) {
         // leia o que bc esta mandando
         // ZF_LOGD("read (%d) %d bytes", size, BSIZE - size);
+        char read_buffer[BSIZE + 1];
+        int total;
+
+        // We may adjust this later on (adjusting read length).
+        if ((total = read(master, read_buffer, BSIZE)) != -1) {
 
-        if ((total = read(master, buffer + size, BSIZE - size)) != -1) {
           // Ok, we've read more into the buffer.
           ZF_LOGV("Read %d bytes", total);
+          buffer.append(read_buffer, total);
+
           // ZF_LOGV_MEM(buffer + size, total, "Read %d bytes:", total);
-          size += total;
+          // size += total;
           // ZF_LOGV_MEM(buffer, size, "Buffer now:");
-          int pos = rstrnstr(buffer, size, "\r\n");
-          if (pos >= 0) {
+
+          int pos = buffer.rfind("\r\n");
+          // rstrnstr(buffer, size, "\r\n");
+          //  >= 0) {
+          if (pos != string::npos) {
             // found something!
+
             pos += 2;
+            // play = buffer.substr() wipes out play's reserve. 
+            // play = buffer.substr(0, pos);
+            play.assign(buffer, 0, pos);
+            ZF_LOGI("play %lu size, %lu cap", play.size(), play.capacity());
+            // play.copy(buffer.data(), pos);
+            //) = buffer.substr(0, pos);
+            buffer.erase(0, pos);
+
+            mangle(STDOUT_FILENO, play);
+
             // ZF_LOGD_MEM(buffer, pos, "mangle buffer %d bytes:", pos);
-            mangle(STDOUT_FILENO, buffer, pos);
-            memmove(buffer, buffer + pos, size - pos);
-            size -= pos;
+            // mangle(STDOUT_FILENO, buffer, pos);
+            // memmove(buffer, buffer + pos, size - pos);
+            // size -= pos;
             // } else {
             //   ZF_LOGV("position of /r/n not found.");
           }
 
+          // Ok, we failed to find CR+NL.  What's the buffer size at?
+
+          if (buffer.size() > BSIZE) {
+            // Ok, there's something going on, and it doesn't look good
+            // unsure if I want to feed this into the console
+            // my guess at this point would be zmodem xfer
+            ZF_LOGI("Buffer %lu bytes, write only...", buffer.size());
+
+            // console_receive(&console, buffer);
+            write(STDOUT_FILENO, buffer.data(), buffer.size());
+            buffer.clear();
+          }
+
         } else
           break;
       }
@@ -1094,7 +475,11 @@ int main(int argc, char *argv[]) {
         int r = read(STDIN_FILENO, &input, BSIZE);
         input[r] = 0;
         // e escreva no bc
-        ZF_LOGI("<< %s", repr(input));
+        if (r > 50) {
+          ZF_LOGI("<< %d bytes", r);
+        } else {
+          ZF_LOGI("<< %s", repr(input));
+        };
 
         write(master, &input, r);
 

terminal.cpp

@@ -15,7 +15,6 @@ Everything else, I'm not sure I really care about.   (NNY!)
 #include "utils.h"
 #include "zf_log.h"
 
-
 void console_init(struct console_details *cdp) {
   cdp->posx = 0;
   cdp->posy = 0;
@@ -372,6 +371,24 @@ void console_string(struct console_details *cdp, const char *chars) {
   }
 }
 
+// extern void log_flush(void);
+
+void console_string(struct console_details *cdp, std::string chars) {
+
+  ZF_LOGI("console_char %lu chars", chars.size());
+
+  /*  // the c way
+  for (int x = 0; x < chars.size(); x++) {
+    console_char(cdp, chars[x]);
+  }
+  */
+
+  // the C++ way
+  for (auto strit = chars.begin(); strit != chars.end(); strit++)
+    console_char(cdp, *strit);
+
+}
+
 void console_receive(struct console_details *cdp, const char *chars, int len) {
   int x;
 

terminal.h

@@ -1,6 +1,8 @@
 #ifndef TERMINAL_H
 #define TERMINAL_H
 
+#include <string>
+
 // TODO:  add class.  :P
 
 struct console_details {
@@ -34,4 +36,5 @@ ANSI_TYPE console_ansi(struct console_details *cdp, const char *ansi);
 termchar console_char(struct console_details *cdp, char ch);
 void console_string(struct console_details *cdp, const char *chars);
 void console_receive(struct console_details *cdp, const char *chars, int len);
+void console_string(struct console_details *cdp, std::string chars);
 #endif

wordplay.cpp

@@ -0,0 +1,683 @@
+#include "render.h"
+#include "terminal.h"
+#include "utils.h"
+#include "lastseen.h"
+#include "images.h"
+#include <string.h>
+#include <string>
+#include <regex.h>
+
+#include "zf_log.h"
+ 
+#include <unistd.h> // write
+
+extern struct console_details console;
+
+#define BSIZE 512
+
+
+void harry_idle_event(int fd) {
+  // Make something happen
+  char buffer[100];
+  int slen;
+  int r;
+  // This is no where near finished, BUT!
+  const char *phrases[] = {"Hahaha",    "Snicker, snicker", "Boo!",
+                           "MeOW",      "I see U",          "Arrooo!",
+                           "Ahh-wooo!", "Aaaooo!"};
+  const char *cp;
+  static LastSeen last_seen_harry_event(2);
+
+  // Remember the last phrase used,
+  // and don't repeat (the last two)!
+
+  do {
+    r = randint((sizeof(phrases) / sizeof(char *)));
+    // r = random() % ((sizeof(phrases) / sizeof(char *)) - 1);
+  } while (last_seen_harry_event.seen_before(r));
+
+  // ZF_LOGD("%d => %d %d", r, last_seen_harry_event[0],
+  // last_seen_harry_event[1]);
+
+  cp = phrases[r];
+  int color = random() % 15 + 1;
+  /*
+  int color = random() % 16;
+  if (color == 0) {
+    color++;
+  } // If it's 0 let's make it 1.   // color = (random() % 15) + 1
+  */
+
+  slen = snprintf(buffer, sizeof(buffer), "^S2^C%02d%s^P2^CR^D%02d", color, cp,
+                  (int)strlen(cp));
+  if (slen >= sizeof(buffer)) {
+    ZF_LOGE("snprintf %d > size %d", slen, (int)sizeof(buffer));
+    buffer[0] = 0;
+  }
+  ZF_LOGD("harry_event: render(%d, \"%s\")", fd, buffer);
+  render(fd, buffer, strlen(buffer));
+}
+
+void init_harry() {
+  // init_have_seen(last_seen_harry_event, MAX_HARRY_EVENT_DUPS);
+  // ZF_LOGD("init => %d %d", last_seen_harry_event[0],
+  // last_seen_harry_event[1]);
+  console_init(&console);
+}
+
+regex_t ANSI;
+regex_t WORDS;
+regex_t WORD;
+
+int init_regex(void) {
+  int ret;
+  char ansi[] = "\x1b\[[0-9]+(;[0-9]+)*?[a-zA-Z]";
+  char words[] = "[a-zA-Z]+( [a-zA-Z]+)+";
+  char word[] = "[a-zA-Z]+";
+  char errorbuf[100];
+
+  if (ret = regcomp(&ANSI, ansi, REG_EXTENDED | REG_NEWLINE)) {
+    regerror(ret, &ANSI, errorbuf, sizeof(errorbuf));
+    ZF_LOGW("Regex %s failed to compile: %s", ansi, errorbuf);
+    return 0;
+  };
+
+  if (ret = regcomp(&WORDS, words, REG_EXTENDED | REG_NEWLINE)) {
+    regerror(ret, &WORDS, errorbuf, sizeof(errorbuf));
+    ZF_LOGW("Regex %s failed to compile: %s", words, errorbuf);
+    return 0;
+  };
+
+  if (ret = regcomp(&WORD, word, REG_EXTENDED | REG_NEWLINE)) {
+    regerror(ret, &WORD, errorbuf, sizeof(errorbuf));
+    ZF_LOGW("Regex %s failed to compile: %s", word, errorbuf);
+    return 0;
+  };
+
+  return 1;
+}
+
+int regmatch(regex_t *preg, const char *string, size_t nmatch,
+             regmatch_t pmatch[], int eflags) {
+  // returns number of matches found.  (Max nmatch)
+  int matches = 0;
+  int offset = 0;
+
+  while (matches < nmatch) {
+    int ret = regexec(preg, string + offset, nmatch - matches, pmatch + matches,
+                      eflags);
+    if (!ret) {
+      int current = offset;
+      offset += pmatch[matches].rm_eo;
+      pmatch[matches].rm_so += current;
+      pmatch[matches].rm_eo += current;
+      matches++;
+    } else if (ret == REG_NOMATCH) {
+      break;
+    } else {
+      break;
+    }
+  }
+  return matches;
+}
+
+#define MAX_MATCH 32
+regmatch_t rxmatch[MAX_MATCH];
+
+int rx_match(regex_t *regex, const char *buffer) {
+  int ret;
+
+  ret = regmatch(regex, buffer, MAX_MATCH, rxmatch, 0);
+  if (0) {
+    for (int i = 0; i < ret; i++) {
+      ZF_LOGI("%d : (%d-%d)", i, rxmatch[i].rm_so, rxmatch[i].rm_eo);
+    }
+  }
+  return ret;
+}
+
+/**
+ * random_activate()
+ *
+ * Is a weight (1-10),
+ * tests if random number is < weight * 10.
+ *
+ * So random_activate(9) happens more frequently
+ * then random_activate(8) or lower.
+ *
+ * This probably needs to be fixed.
+ * We need a better randint(RANGE) code.
+ */
+int random_activate(int w) {
+  int r = randint(100);
+  if (r <= (w * 10)) {
+    return 1;
+  };
+  return 0;
+}
+
+/*
+  word_state():    // deprecated
+
+  -1 only lower
+  +1 only upper
+   0 mixed
+*/
+int word_state(const char *buffer, int len) {
+  int p;
+  int upper = 0;
+  int lower = 0;
+  int ret;
+  float pct;
+
+  for (p = 0; p < len; p++) {
+    char c = buffer[p];
+    if (isalpha(c)) {
+      if (isupper(c)) {
+        upper++;
+      };
+      if (islower(c)) {
+        lower++;
+      };
+    }
+  }
+
+  if (upper == lower) {
+    return 0;
+  }
+
+  if (upper > lower) {
+    ret = 1;
+    pct = ((float)lower / (float)upper) * 100.0;
+  } else {
+    ret = -1;
+    pct = ((float)upper / (float)lower) * 100.0;
+  }
+
+  // ZF_LOGD("So far %d with %f %%", ret, pct);
+
+  if (pct < 40.0) {
+    return ret;
+  }
+  return 0;
+}
+
+/*
+Given a buffer and length, mangle away.
+
+toupper, tolower, flipper
+ */
+int word_mangler(char *buffer, int len) {
+  int p;
+  int count = 0;
+  int state;
+
+  // state = word_state(buffer, len);
+  // ZF_LOGD("word_state(%.*s) %d", len, buffer, state);
+  state = randrange(-1, 1);
+
+  // TODO:  Transposer
+
+  for (p = 0; p < len; p++) {
+    char c = buffer[p];
+
+    if (randint(len) == p) {
+      break;
+    }
+    switch (state) {
+    case -1:
+      // upper
+      if (islower(c)) {
+        count++;
+        buffer[p] = toupper(c);
+      }
+      break;
+    case 1:
+      // lower
+      if (isupper(c)) {
+        count++;
+        buffer[p] = tolower(c);
+      }
+      break;
+    case 0:
+      // flipper
+      if (islower(c)) {
+        count++;
+        buffer[p] = toupper(c);
+      } else {
+        if (isupper(c)) {
+          count++;
+          buffer[p] = tolower(c);
+        }
+      }
+      break;
+    }
+  }
+  return count;
+}
+
+int word_wrangler(char *buffer, int len) {
+  int p;
+  int count;
+  int state;
+
+  // state = word_state(buffer, len);
+  // ZF_LOGD("word_state(%.*s) %d", len, buffer, state);
+  if (len < 5) {
+    return 0;
+  }
+
+  p = randint(len - 4) + 2;
+
+  for (count = 0; count < 4; count++) {
+    if (!isalpha(buffer[p + count]))
+      break;
+  }
+
+  ZF_LOGV_MEM(buffer, len, "wrangler %d len %d:", p, count);
+
+  if (count >= 2) {
+    for (int x = 0; x < count / 2; x++) {
+      char ch = buffer[p + x];
+      buffer[p + x] = buffer[p + count - 1 - x];
+      buffer[p + count - 1 - x] = ch;
+    }
+    ZF_LOGV_MEM(buffer, len, "word now:");
+    return 1;
+  } else
+    return 0;
+}
+
+int buffer_insert(char *buffer, int len, int max_length, int pos,
+                  const char *insert) {
+  if (len + strlen(insert) > max_length) {
+    ZF_LOGD("buffer_insert failed [%s]", repr(insert));
+    return 0;
+  }
+  memmove(buffer + pos + strlen(insert), buffer + pos, len - pos);
+  strncpy(buffer + pos, insert, strlen(insert));
+  return 1;
+}
+
+/*
+ * The buffer that we've been given is much larger now.
+ *
+ * We can no longer mangle or insert into the given buffer.
+ * Why?  Because we don't know what is behind it now!
+ */
+int mangle(int fd, const char *buffer, int len) {
+  int x, i;
+  int need_render = 0; // changing word case around doesn't need the render
+  int mangled = 0;
+  int mangled_chars = 0;
+  char play[BSIZE * 2]; // The main buffer to send.
+  const char *cp;
+
+  // Make a copy of buffer, since it can no longer be changed
+  // inserted into.
+
+  memcpy(play, buffer, len);
+
+  // NEVER reference buffer from this point on!
+
+  char work[BSIZE * 2]; // The mess with buffer.
+
+  /*
+   We use the work buffer to blank out the ANSI
+   before trying to locate words.  (So we don't
+   grab part of the ANSI codes and mangle those!)
+  */
+
+  // Use terminal - clean out ANSI
+
+  // ZF_LOGI("mangle:");
+  ZF_LOGI_MEM(play, len, "Mangle (%u bytes):", len);
+
+  // strcpy(work, buffer);
+
+  /*
+  NOTE:  We copy the buffer, so we can clear out ANSI codes, etc.
+  Otherwise we might mess some ANSI up in the manglying
+  process.
+  */
+
+  /*
+  Is there a way to track -- what I've inserted, and make it exempt from
+  other modifications / mangler, wrangler?
+   */
+
+  /*
+   (random) Look for ANSI CLS and:
+
+      display random spooky texts around, with delays ... then CLS.
+
+      display ANSI graphic file, with delays ... then CLS
+   */
+  const char *ANSI_CLS = "\x1b[2J";
+  cp = strnstr(play, len, ANSI_CLS); // strstr(buffer, ANSI_CLS);
+
+  if (cp != NULL) {
+    static int ANSI_CLS_count = 0; // count the number we've seen
+    ZF_LOGI("seen: ANSI_CLS");
+    ANSI_CLS_count++;
+
+    // Don't activate on the very first CLS.  Too soon, don't screw up the ANSI
+    // detection.
+    if (ANSI_CLS_count > 1) {
+      // Ok, figure out the restore color, just in case
+      struct console_details temp_console;
+      // Make exact copy of our current console state.
+      memcpy(&temp_console, &console, sizeof(console));
+      // Play the buffer into the console
+      console_receive(&temp_console, play, cp - play);
+      char restore_color[30]; // ansi color
+      strcpy(restore_color, color_restore(&temp_console));
+
+      if (random_activate(3)) {
+        char display[100] = "";
+        int slen;
+        int needs_cls = 0;
+
+        struct image {
+          const char **lines;
+          int size;
+          int cls;
+          int width; // height = size
+        } images[] = {{ghost, sizeof(ghost) / sizeof(char *), 1, 0},
+                      {ghead, sizeof(ghead) / sizeof(char *), 1, 0},
+                      {wolf, sizeof(wolf) / sizeof(char *), 1, 0},
+                      {panther, sizeof(panther) / sizeof(char *), 1, 0},
+                      {bat, sizeof(bat) / sizeof(char *), 1, 0},
+                      {icu, sizeof(icu) / sizeof(char *), 0, 20},
+                      {skull, sizeof(skull) / sizeof(char *), 0, 19},
+                      {skullblink, sizeof(skullblink) / sizeof(char *), 0, 19}};
+
+        static LastSeen last_files(2);
+        int r;
+
+        do {
+          r = randint((sizeof(images) / sizeof(image)));
+        } while (last_files.seen_before(r));
+
+        char fgoto[32];
+
+        if (!images[r].cls) {
+          int x = 0, y = 0;
+
+          x = randint(79 - images[r].width);
+          y = randint(24 - images[r].size);
+
+          int slen;
+          // render image, home cursor
+          slen = snprintf(fgoto, sizeof(fgoto), "^f%02d%02d\x1b[1;1H", x, y);
+          if (slen >= sizeof(fgoto)) {
+            ZF_LOGE("snprintf %d > size %d", slen, (int)sizeof(fgoto));
+            fgoto[0] = 0;
+          }
+        } else {
+          strcpy(fgoto, "^F");
+        }
+
+        // (2); // (sizeof(possibles) / sizeof(file_need)) - 1);
+        needs_cls = images[r].cls;
+
+        // I get what's happening.  Mystic moves cursor to home, CLS, cursor
+        // home. When we get here, we're ALWAYS at the top of the screen...
+        // Hence our bat isn't displayed at the end of the screen.
+
+        // This is before the actual CLS, so we CLS before displaying our files.
+        // I tried a ^P2 before doing this .. but I'd rather have the picture up
+        // right away I think.
+
+        // Ok, yes, there's no filename being sent.  :P
+        render_image(images[r].lines, images[r].size);
+
+        slen = snprintf(display, sizeof(display), "%s%s%s^P3",
+                        needs_cls ? "\x1b[2J" : "", fgoto, restore_color);
+        if (slen >= sizeof(display)) {
+          ZF_LOGE("snprintf %d > size %d", slen, (int)sizeof(display));
+          display[0] = 0;
+        }
+        ZF_LOGI("mangle(ANSI_CLS): %d file inserted %s", r, repr(display));
+
+        // Move the buffer so there's room for the display string.
+        if (buffer_insert(play, len, sizeof(play), cp - play, display)) {
+          len += strlen(display);
+          // if (string_insert(buffer, 1024, cp - buffer, display)) {
+
+          ZF_LOGI_MEM(play, len, "mangle(ANSI_CLS) (%u bytes):", len);
+          // ZF_LOGI("mangle(ANSI_CLS):");
+          // ZF_LOGI_REPR(buffer);
+          // ZF_LOGI("mangle(ANSI_CLS): [%s]", repr(buffer));
+          need_render = 1;
+
+          /*
+          Copy the new buffer over, but hide our "render" code
+          from the remaining mangler steps.
+          */
+          memcpy(work, play, len);
+          // strcpy(work, buffer);
+          i = cp - play;
+          // find offset into "buffer"
+          // apply to work.
+          memset(work + i, ' ', strlen(display));
+
+        } else {
+          ZF_LOGD("insert failed [%s].", repr(display));
+        }
+      } else {
+        if (random_activate(4)) {
+          int r;
+          char display[100] = "";
+          int slen;
+
+          /*
+          Interesting note here:
+          "Anyone there" qualifies as a valid WORDS regex match.
+          It is possible that it can get mangled/wrangled!
+          */
+          const char *phrasing[] = {
+              "^R1Haha^P1ha^P1ha", "Poof!", "Got U", "Anyone there?",
+              "^R1Knock, ^P1Knock",
+              /*
+              This picks random color and position -- then
+              homes cursor and changes to another color.  (This can be seen.)
+               */
+              "^G0101^C07^S9Segmentation fault (core dumped)^P2"};
+          static LastSeen last_phrasing(2);
+
+          ZF_LOGI("mangle(ANSI_CLS)");
+          // sprintf( display, "^P2...");
+          // This string actually screws up ANSI detection (takes too long)
+          // strcpy(display, "^P2^S501234567890^P1abcdef^P2g^P3h^P4i^S0^P2");
+
+          // strcpy(display, "^P2^S301234^P15^S0^P2");
+
+          // Add in random text, plus color!
+          do {
+            r = randint(sizeof(phrasing) / sizeof(char *));
+          } while (last_phrasing.seen_before(r));
+
+          int color = random() % 15 + 1;
+          int x = random() % 30 + 1;
+          int y = random() % 15 + 1;
+
+          /*
+          Don't have it pause there before moving the cursor.
+
+          Move the cursor, get the color changed, THEN pause.
+          Then act all crazy.
+
+          NOTE:  Make sure if you use any ^R Render effects, turn them off
+          before trying to display the restore_color.  :P   ^R0 Also, make
+          sure you re-home the cursor ^G0101 because that's where they are
+          expecting the cursor to be!  (At least it's how Mystic does it.)
+
+          HOME, CLS, HOME, ...  Not sure what others do there.  We'll see.
+          */
+
+          slen = snprintf(display, sizeof(display),
+                          "^G%02d%02d^S3^C%02d^P1%s^S0^R0%s^P1^G0101", x, y,
+                          color, phrasing[r], restore_color);
+          if (slen >= sizeof(display)) {
+            ZF_LOGE("snprintf %d > size %d (Phrase: %d, %s)", slen,
+                    (int)sizeof(display), r, phrasing[r]);
+            display[0] = 0;
+          }
+
+          // sprintf(display, "^P1^S3^C%02d%s^S0^R0%s^P1", color, phrasing[r],
+          // restore_color);
+          // Added debug statement so we can identify what was sent... color,
+          // number picked and what that is
+          ZF_LOGD("mangle(ANSI_CLS): Inserted color=%02d r=%d phrase='%s'",
+                  color, r, phrasing[r]);
+          ZF_LOGI_MEM(play, len, "mangle(ANSI_CLS) :");
+
+          // Move the buffer so there's room for the display string.
+          if (buffer_insert(play, len, sizeof(play), cp - play, display)) {
+            len += strlen(display);
+
+            // if (string_insert(buffer, BSIZE * 4, cp - buffer, display)) {
+            ZF_LOGI_MEM(play, len, "mangle(ANSI_CLS) + :");
+            // ZF_LOGI("mangle(ANSI_CLS):");
+            // ZF_LOGI_REPR(buffer);
+            need_render = 1;
+
+            /*
+            Copy the new buffer over, but hide our "render" code
+            from the remaining mangler steps.
+            */
+            memcpy(work, play, len);
+            // strcpy(work, buffer);
+            i = cp - play;
+            // find offset into "buffer"
+            // apply to work.
+            memset(work + i, ' ', strlen(display));
+
+          } else {
+            ZF_LOGD("insert failed [%s].", repr(display));
+          }
+        }
+      }
+    }
+  }
+
+  memcpy(work, play, len);
+
+  // strcpy(work, buffer); // sure.
+
+  // NOTE: This is NOT aware of my ^TRIGGERS, so they will show up
+  // as valid things to mangle in work.  (Keep this in mind).
+
+  const char replace_with = ' ';
+  for (x = 0; x < len; x++) {
+    termchar tc = console_char(&console, play[x]);
+    int ansi = tc.in_ansi;
+
+    if (ansi) {
+      work[x] = replace_with;
+      if (tc.ansi != START) {
+        ZF_LOGD("ANSI type %d at %d", tc.ansi, x);
+      }
+    }
+    // fixup "work" so it's a valid C string
+    if (buffer[x] == 0) {
+      work[x] = replace_with;
+    }
+  }
+  // fixup "work" buffer so it's a valid c string
+  // (required for regex to work.)
+  work[len] = 0;
+
+  ZF_LOGV_MEM(work, len, "Work now:");
+
+  /*
+   (random) Locate words (in work), and possibly flip them around.
+   Transpose words.  Transpose case.  Transpose letters.
+
+   Ok, what would be interesting, is if we could find
+   W\x1[0;34mORDS with color changes in them, and work with them.
+   without screwing up the color changes, of course.  :P
+
+  Example:
+
+   Y\x1b[0;1mes \x1b[0;1;34m\x1b[0;1;34;44m N\x1b[0;1;44mo
+   Yes No
+   ^ This would be a job for a crazy regex.
+
+   I'd have to map the characters to positions in the buffer.  :S
+   I'd want mangle and wrangle to work.
+
+   The Message menu -- doesn't hardly get mangled at all (at least on
+   my test site).  Because all of the color changes break up the
+   words in the menu.
+   */
+  x = rx_match(&WORDS, work);
+  ZF_LOGD("found %d word groups", x);
+
+  if (x > 0) {
+    for (i = 0; i < x; i++) {
+
+      // Yes!  Be random!
+      if (random_activate(8)) {
+        int c = word_mangler(play + rxmatch[i].rm_so,
+                             rxmatch[i].rm_eo - rxmatch[i].rm_so);
+        if (c) {
+          mangled++;
+          mangled_chars += c;
+        }
+      }
+
+      if (random_activate(4)) {
+        word_wrangler(play + rxmatch[i].rm_so,
+                      rxmatch[i].rm_eo - rxmatch[i].rm_so);
+      }
+    }
+  }
+
+  /*
+   (random) Locate single words, and transpose words.
+   Transpose letters.
+   */
+
+  /*
+   (random) Display up to certain point.  Delay.
+   Print some characters slowly.  Delay.
+   */
+
+  if (mangled)
+    ZF_LOGI("Mangled %d word, %d chars (render %d)", mangled, mangled_chars,
+            need_render);
+
+  if (need_render) {
+    ZF_LOGD_MEM(play, len, "Ready to render:");
+    // ZF_LOGD("HH %d : (%d) %s", need_render, (int)strlen(buffer),
+    // repr(buffer));
+  }
+
+  if (need_render) {
+    render(fd, play, len);
+  } else {
+    write(fd, play, len);
+  };
+  return need_render && mangled;
+}
+
+int harry_happens(time_t *last_event, int wakeup) {
+  time_t now = time(NULL);
+  int elapsed = now - *last_event;
+
+  if (elapsed > wakeup) {
+    // Ok!  It's been too long since we've done something.
+    *last_event = now;
+    return 1;
+  }
+  return 0;
+}
+
+
+int mangle(int fd, std::string buffer) {
+  // a simple default for now.
+  ZF_LOGI_MEM(buffer.data(), buffer.size(), "mangle(%d): %lu bytes", fd, buffer.size());
+  write(fd, buffer.data(), buffer.size());
+}

wordplay.h

@@ -0,0 +1,8 @@
+#ifndef WORDPLAY_H
+#define WORDPLAY_H
+void harry_idle_event(int fd);
+void init_harry();
+int init_regex(void);
+int mangle(int fd, const char *buffer, int len);
+int mangle(int fd, string buffer);
+#endif