Regex in c++.

hharry.cpp

@@ -270,8 +270,9 @@ int main(int argc, char *argv[]) {
     ZF_LOGD("Username: [%s] A.K.A. [%s]", username, fullname);
   }
 
+  /*
   if (!init_regex())
-    return 2;
+    return 2;  */
 
   pid = forkpty(&master, NULL, NULL, NULL);
 

input-int.cpp

@@ -0,0 +1,81 @@
+// Example 1
+#include <iostream>
+#include <regex>
+#include <string>
+
+using namespace std;
+
+int main() {
+  string input;
+  // regex integer("(\\+|-)?[[:digit:]]+");
+  regex integer("(\\+|-)?([[:digit:]]+)");
+  smatch match;
+  // As long as the input is correct ask for another number
+  while (true) {
+    cout << "Give me an integer! (q to quit)" << endl;
+    getline(cin, input);
+    // cin >> input;
+    if (!cin)
+      break;
+    // Exit when the user inputs q
+    if (input == "q")
+      break;
+
+    // Apparently, hitting enter, doesn't give you a blank input!  use getline.
+
+    cout << "Length: " << input.length() << " Empty? " << input.empty() << endl;
+    if (input.empty())
+      break;
+
+    // I need position and length.
+    vector<pair<int,int>> pos_len;
+
+    for (auto it = sregex_iterator(input.begin(), input.end(), integer);
+         it != sregex_iterator(); ++it) {
+	    pos_len.push_back(make_pair(it->position(), it->length() ) );
+      cout << it->position() << " " << it->length() << " : " << it->str()
+           << endl;
+    }
+
+    for (vector<pair<int,int>>::iterator vit = pos_len.begin(); vit != pos_len.end(); ++vit ) {
+	    pair<int,int> p;
+		p = *vit;
+    cout << (*vit).first << "," << (*vit).second << endl;
+    cout << p.first << "," << p.second << endl;
+	}
+
+#ifdef RX1
+    if (regex_match(input, match, integer)) {  
+      cout << "integer" << endl;
+      for (int i = 0; i < match.size(); ++i) {
+        std::cout << "match " << i << " (" << match[i] << ") At "
+                  << match.position(i) << " of " << match.length(i) << " chars."
+                  << endl;
+      }
+      for (smatch::iterator im = match.begin(); im != match.end(); ++im) {
+        cout << "matches:" << *im << std::endl;
+      }
+    } else {
+      cout << "Invalid input" << endl;
+    }
+
+    int offset = 0;
+    while (regex_search(input, match, integer)) {
+      cout << "input: [" << input << "]" << endl;
+      cout << offset << " match len " << match.length(0) << endl;
+      for (int i = 0; i < match.size(); ++i) {
+        std::cout << "match " << i << " (" << match[i] << ") At "
+                  << offset + match.position(i) << " of " << match.length(i)
+                  << " chars." << endl;
+      }
+
+      for (auto x : match) {
+        cout << x << " ";
+      }
+      cout << endl;
+      input = match.suffix().str();
+      offset += match.length(0) + match.prefix(0).size();
+    }
+#endif
+  }
+}

wordplay.cpp

@@ -4,9 +4,9 @@
 #include "terminal.h"
 #include "utils.h"
 #include <iomanip>
-#include <regex.h>
+#include <regex>
 #include <sstream>
-#include <string.h>
+// #include <string.h>
 #include <string>
 #include <vector>
 
@@ -67,6 +67,7 @@ void init_harry() {
   console_init(&console);
 }
 
+#ifdef UNWANTED
 regex_t ANSI;
 regex_t WORDS;
 regex_t WORD;
@@ -137,6 +138,7 @@ int rx_match(regex_t *regex, const char *buffer) {
   }
   return ret;
 }
+#endif
 
 /**
  * random_activate()
@@ -209,6 +211,12 @@ Given a buffer and length, mangle away.
 
 toupper, tolower, flipper
  */
+int word_mangler(std::string &buffer, std::string& word, std::string& text, std::vector<int> &text_offsets, std::pair<int,int> pos_len) {
+
+}
+
+#ifdef UNWANTED
+
 int word_mangler(char *buffer, int len) {
   int p;
   int count = 0;
@@ -300,7 +308,9 @@ int buffer_insert(char *buffer, int len, int max_length, int pos,
   strncpy(buffer + pos, insert, strlen(insert));
   return 1;
 }
+#endif
 
+#ifdef UNWANTED
 /*
  * The buffer that we've been given is much larger now.
  *
@@ -664,7 +674,9 @@ int mangle(int fd, const char *buffer, int len) {
   };
   return need_render && mangled;
 }
+#endif
 
+/*
 int harry_happens(time_t *last_event, int wakeup) {
   time_t now = time(NULL);
   int elapsed = now - *last_event;
@@ -676,6 +688,32 @@ int harry_happens(time_t *last_event, int wakeup) {
   }
   return 0;
 }
+*/
+
+/*
+ * find_words()
+ * 
+ * This uses regex to look for words where a word is defined as one or more letter.
+ * 
+ * We do throw out words with a len of 3.  (That would be "A B".  We don't want that.)
+ * We return a vector of pairs (position, length), and the number of matches.
+ */
+int find_words(std::string &text, std::vector<std::pair<int, int>> &words) {
+  words.clear();
+// Yes I want & in there so BZ&BZ BBS matches.  
+  std::regex words_re("[a-zA-Z&]+( [a-zA-Z&]+)+");
+  int count = 0;
+
+  for (auto it = std::sregex_iterator(text.begin(), text.end(), words_re);
+       it != std::sregex_iterator(); ++it) {
+    if (it->length() > 3) {
+      words.push_back(std::make_pair(it->position(), it->length()));
+      count++;
+    }
+  }
+
+  return count;
+}
 
 int mangle_clrscr(std::string &buffer, std::string &work, size_t pos) {
   static int ANSI_CLS_count = 0;
@@ -839,9 +877,9 @@ int mangle_clrscr(std::string &buffer, std::string &work, size_t pos) {
   }
 }
 
-int mangle(int fd, std::string buffer) {
+int mangle(int fd, std::string &buffer) {
   // a simple default for now.
-  ZF_LOGI_MEM(buffer.data(), buffer.size(), "mangle(%d): %lu bytes", fd,
+  ZF_LOGV_MEM(buffer.data(), buffer.size(), "mangle(%d): %lu bytes", fd,
               buffer.size());
 
   int need_render = 0;
@@ -876,14 +914,12 @@ int mangle(int fd, std::string buffer) {
   text_offsets.clear();
 
   for (stri = 0; stri < buffer.size(); ++stri) {
-    // why wasn't \x1b[?1000h   handled by console_char?
-    // what happened to \x0c ?   It is there.
     termchar tc = console_char(&console, work[stri]);
 
     if (tc.in_ansi) {
       if (tc.ansi != START) {
         // Ok, this is something.  What is it?
-        ZF_LOGD("ANSI type %d at %lu", tc.ansi, stri);
+        // ZF_LOGV("ANSI type %d at %lu", tc.ansi, stri);
         switch (tc.ansi) {
         case CURSOR:
         case CLEAR:
@@ -908,11 +944,12 @@ int mangle(int fd, std::string buffer) {
     }
   }
 
+  // The current situation:
   ZF_LOGD_MEM(buffer.data(), buffer.size(), "Buffer:");
   ZF_LOGD_MEM(work.data(), work.size(), "Work:");
-
   ZF_LOGD_MEM(text.data(), text.size(), "Text Buffer:");
 
+  // output vector information
   std::ostringstream oss;
   int comma = 0;
   for (auto it = std::begin(text_offsets); it != std::end(text_offsets); ++it) {
@@ -931,9 +968,39 @@ int mangle(int fd, std::string buffer) {
     }
   }
   std::string vector_output = oss.str();
-
   ZF_LOGD("Vector: %s", vector_output.c_str());
 
+  // find matches
+  std::vector<std::pair<int, int>> words;
+
+  int found = find_words(text, words);
+  ZF_LOGD("Found %d word groups in text.", found);
+
+  if (found > 0) {
+    for (int i = 0; i < found; i++) {
+      std::pair<int, int> pos_len = words[i];
+
+      // Yes!  Be random!
+      if (random_activate(8)) {
+        int c = word_mangler(buffer, work, text, text_offsets, pos_len);
+        /*
+        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);
+                      */
+      }
+    }
+  }
+
   if (need_render) {
     render(fd, buffer);
   } else {

wordplay.h

@@ -2,7 +2,7 @@
 #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);
+/* int init_regex(void); */
+/* int mangle(int fd, const char *buffer, int len); */
+int mangle(int fd, string& buffer);
 #endif