From 4690ce81e079fc58cae8d6d583e5e3eb3ed81a83 Mon Sep 17 00:00:00 2001 From: "Kartik K. Agaram" Date: Wed, 9 Mar 2016 02:56:27 -0800 Subject: 2743 Looks like "TOhtml | " doesn't work on Mac OS X for some reason.. --- html/003trace.cc.html | 186 ++++++++++++++++++++++++-------------------------- 1 file changed, 89 insertions(+), 97 deletions(-) (limited to 'html/003trace.cc.html') diff --git a/html/003trace.cc.html b/html/003trace.cc.html index a835d7ab..c2dd0cb1 100644 --- a/html/003trace.cc.html +++ b/html/003trace.cc.html @@ -3,33 +3,26 @@ Mu - 003trace.cc - - + + - - + - - -
+
 //: The goal of this skeleton is to make programs more easy to understand and
 //: more malleable, easy to rewrite in radical ways without accidentally
 //: breaking some corner case. Tests further both goals. They help
@@ -113,57 +106,57 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; }
 // End Tracing  // hack to ensure most code in this layer comes before anything else
 
 :(before "End Types")
-struct trace_line {
-  int depth;  // optional field just to help browse traces later
+struct trace_line {
+  int depth;  // optional field just to help browse traces later
   string label;
   string contents;
   trace_line(string l, string c) :depth(0), label(l), contents(c) {}
-  trace_line(int d, string l, string c) :depth(d), label(l), contents(c) {}
+  trace_line(int d, string l, string c) :depth(d), label(l), contents(c) {}
 };
 
 :(before "End Globals")
-const int Max_depth = 9999;
-const int Error_depth = 0;  // definitely always print errors
-const int App_depth = 2;  // temporarily where all mu code will trace to
+const int Max_depth = 9999;
+const int Error_depth = 0;  // definitely always print errors
+const int App_depth = 2;  // temporarily where all mu code will trace to
 :(before "End Tracing")
-bool Hide_errors = false;
+bool Hide_errors = false;
 :(before "End Setup")
 Hide_errors = false;
 
 :(before "End Tracing")
-struct trace_stream {
+struct trace_stream {
   vector<trace_line> past_lines;
   // accumulator for current line
   ostringstream* curr_stream;
   string curr_label;
-  int curr_depth;
-  int callstack_depth;
-  int collect_depth;
+  int curr_depth;
+  int callstack_depth;
+  int collect_depth;
   ofstream null_stream;  // never opens a file, so writes silently fail
   trace_stream() :curr_stream(NULL), curr_depth(Max_depth), callstack_depth(0), collect_depth(Max_depth) {}
-  ~trace_stream() { if (curr_stream) delete curr_stream; }
+  ~trace_stream() { if (curr_stream) delete curr_stream; }
 
   ostream& stream(string label) {
     return stream(Max_depth, label);
   }
 
-  ostream& stream(int depth, string label) {
-    if (depth > collect_depth) return null_stream;
-    curr_stream = new ostringstream;
+  ostream& stream(int depth, string label) {
+    if (depth > collect_depth) return null_stream;
+    curr_stream = new ostringstream;
     curr_label = label;
     curr_depth = depth;
     return *curr_stream;
   }
 
   // be sure to call this before messing with curr_stream or curr_label
-  void newline() {
-    if (!curr_stream) return;
+  void newline() {
+    if (!curr_stream) return;
     string curr_contents = curr_stream->str();
-    if (curr_contents.empty()) return;
+    if (curr_contents.empty()) return;
     past_lines.push_back(trace_line(curr_depth, trim(curr_label), curr_contents));  // preserve indent in contents
-    if (!Hide_errors && curr_label == "error")
+    if (!Hide_errors && curr_label == "error")
       cerr << curr_label << ": " << curr_contents << '\n';
-    delete curr_stream;
+    delete curr_stream;
     curr_stream = NULL;
     curr_label.clear();
     curr_depth = Max_depth;
@@ -173,8 +166,8 @@ struct trace_stream {
   string readable_contents(string label) {  // empty label = show everything
     ostringstream output;
     label = trim(label);
-    for (vector<trace_line>::iterator p = past_lines.begin(); p != past_lines.end(); ++p)
-      if (label.empty() || label == p->label) {
+    for (vector<trace_line>::iterator p = past_lines.begin(); p != past_lines.end(); ++p)
+      if (label.empty() || label == p->label) {
         output << std::setw(4) << p->depth << ' ' << p->label << ": " << p->contents << '\n';
       }
     return output.str();
@@ -189,43 +182,43 @@ trace_stream* Trace_stream = NULL#define trace(...)  !Trace_stream ? cerr /*print nothing*/ : Trace_stream->stream(__VA_ARGS__)
 
 // Errors are a special layer.
-#define raise_error  (!Trace_stream ? (tb_shutdown(),cerr) /*do print*/ : Trace_stream->stream(Error_depth, "error"))
+#define raise  (!Trace_stream ? (tb_shutdown(),cerr) /*do print*/ : Trace_stream->stream(Error_depth, "error"))
 // Inside tests, fail any tests that displayed (unexpected) errors.
 // Expected errors in tests should always be hidden and silently checked for.
 :(before "End Test Teardown")
-if (Passed && !Hide_errors && trace_count("error") > 0) {
+if (Passed && !Hide_errors && trace_count("error") > 0) {
   Passed = false;
   ++Num_failures;
 }
 
 :(before "End Types")
-struct end {};
+struct end {};
 :(before "End Tracing")
-ostream& operator<<(ostream& os, unused end) {
-  if (Trace_stream) Trace_stream->newline();
+ostream& operator<<(ostream& os, unused end) {
+  if (Trace_stream) Trace_stream->newline();
   return os;
 }
 
-#define CLEAR_TRACE  delete Trace_stream, Trace_stream = new trace_stream;
+#define CLEAR_TRACE  delete Trace_stream, Trace_stream = new trace_stream;
 
-#define DUMP(label)  if (Trace_stream) cerr << Trace_stream->readable_contents(label);
+#define DUMP(label)  if (Trace_stream) cerr << Trace_stream->readable_contents(label);
 
 // All scenarios save their traces in the repo, just like code. This gives
 // future readers more meat when they try to make sense of a new project.
-static string Trace_dir = ".traces/";
+static string Trace_dir = ".traces/";
 string Trace_file;
 
 // Trace_stream is a resource, lease_tracer uses RAII to manage it.
-struct lease_tracer {
-  lease_tracer() { Trace_stream = new trace_stream; }
+struct lease_tracer {
+  lease_tracer() { Trace_stream = new trace_stream; }
   ~lease_tracer() {
-    if (!Trace_stream) return;  // in case tests close Trace_stream
-    if (!Trace_file.empty()) {
+    if (!Trace_stream) return;  // in case tests close Trace_stream
+    if (!Trace_file.empty()) {
       ofstream fout((Trace_dir+Trace_file).c_str());
       fout << Trace_stream->readable_contents("");
       fout.close();
     }
-    delete Trace_stream, Trace_stream = NULL, Trace_file = "";
+    delete Trace_stream, Trace_stream = NULL, Trace_file = "";
   }
 };
 
@@ -237,44 +230,44 @@ START_TRACING_UNTIL_END_OF_SCOPE
 #define CHECK_TRACE_CONTENTS(...)  check_trace_contents(__FUNCTION__, __FILE__, __LINE__, __VA_ARGS__)
 
 :(before "End Tracing")
-bool check_trace_contents(string FUNCTION, string FILE, int LINE, string expected) {
-  if (!Trace_stream) return false;
+bool check_trace_contents(string FUNCTION, string FILE, int LINE, string expected) {
+  if (!Trace_stream) return false;
   vector<string> expected_lines = split(expected, "^D");
-  long long int curr_expected_line = 0;
-  while (curr_expected_line < SIZE(expected_lines) && expected_lines.at(curr_expected_line).empty())
+  long long int curr_expected_line = 0;
+  while (curr_expected_line < SIZE(expected_lines) && expected_lines.at(curr_expected_line).empty())
     ++curr_expected_line;
-  if (curr_expected_line == SIZE(expected_lines)) return true;
+  if (curr_expected_line == SIZE(expected_lines)) return true;
   string label, contents;
   split_label_contents(expected_lines.at(curr_expected_line), &label, &contents);
-  for (vector<trace_line>::iterator p = Trace_stream->past_lines.begin(); p != Trace_stream->past_lines.end(); ++p) {
-    if (label != p->label)
+  for (vector<trace_line>::iterator p = Trace_stream->past_lines.begin(); p != Trace_stream->past_lines.end(); ++p) {
+    if (label != p->label)
       continue;
 
-    if (contents != trim(p->contents))
+    if (contents != trim(p->contents))
       continue;
 
     ++curr_expected_line;
-    while (curr_expected_line < SIZE(expected_lines) && expected_lines.at(curr_expected_line).empty())
+    while (curr_expected_line < SIZE(expected_lines) && expected_lines.at(curr_expected_line).empty())
       ++curr_expected_line;
-    if (curr_expected_line == SIZE(expected_lines)) return true;
+    if (curr_expected_line == SIZE(expected_lines)) return true;
     split_label_contents(expected_lines.at(curr_expected_line), &label, &contents);
   }
 
   ++Num_failures;
-  cerr << "\nF - " << FUNCTION << "(" << FILE << ":" << LINE << "): missing [" << contents << "] in trace:\n";
+  cerr << "\nF - " << FUNCTION << "(" << FILE << ":" << LINE << "): missing [" << contents << "] in trace:\n";
   DUMP(label);
   Passed = false;
   return false;
 }
 
-void split_label_contents(const string& s, string* label, string* contents) {
-  static const string delim(": ");
-  size_t pos = s.find(delim);
-  if (pos == string::npos) {
+void split_label_contents(const string& s, string* label, string* contents) {
+  static const string delim(": ");
+  size_t pos = s.find(delim);
+  if (pos == string::npos) {
     *label = "";
     *contents = trim(s);
   }
-  else {
+  else {
     *label = trim(s.substr(0, pos));
     *contents = trim(s.substr(pos+SIZE(delim)));
   }
@@ -282,16 +275,16 @@ void split_label_contents(const string& s(string label) {
+int trace_count(string label) {
   return trace_count(label, "");
 }
 
-int trace_count(string label, string line) {
-  if (!Trace_stream) return 0;
-  long result = 0;
-  for (vector<trace_line>::iterator p = Trace_stream->past_lines.begin(); p != Trace_stream->past_lines.end(); ++p) {
-    if (label == p->label) {
-      if (line == "" || trim(line) == trim(p->contents))
+int trace_count(string label, string line) {
+  if (!Trace_stream) return 0;
+  long result = 0;
+  for (vector<trace_line>::iterator p = Trace_stream->past_lines.begin(); p != Trace_stream->past_lines.end(); ++p) {
+    if (label == p->label) {
+      if (line == "" || trim(line) == trim(p->contents))
         ++result;
     }
   }
@@ -300,7 +293,7 @@ int trace_count(string label#define CHECK_TRACE_CONTAINS_ERROR()  CHECK(trace_count("error") > 0)
 #define CHECK_TRACE_DOESNT_CONTAIN_ERROR() \
-  if (trace_count("error") > 0) { \
+  if (trace_count("error") > 0) { \
     ++Num_failures; \
     cerr << "\nF - " << __FUNCTION__ << "(" << __FILE__ << ":" << __LINE__ << "): unexpected errors\n"; \
     DUMP("error"); \
@@ -309,7 +302,7 @@ int trace_count(string label  }
 
 #define CHECK_TRACE_COUNT(label, count) \
-  if (trace_count(label) != (count)) { \
+  if (trace_count(label) != (count)) { \
     ++Num_failures; \
     cerr << "\nF - " << __FUNCTION__ << "(" << __FILE__ << ":" << __LINE__ << "): trace_count of " << label << " should be " << count << '\n'; \
     cerr << "  got " << trace_count(label) << '\n';  /* multiple eval */ \
@@ -318,11 +311,11 @@ int trace_count(string label    return;  /* Currently we stop at the very first failure. */ \
   }
 
-bool trace_doesnt_contain(string label, string line) {
+bool trace_doesnt_contain(string label, string line) {
   return trace_count(label, line) == 0;
 }
 
-bool trace_doesnt_contain(string expected) {
+bool trace_doesnt_contain(string expected) {
   vector<string> tmp = split_first(expected, ": ");
   return trace_doesnt_contain(tmp.at(0), tmp.at(1));
 }
@@ -333,9 +326,9 @@ bool trace_doesnt_contain(string expected(string s, string delim) {
   vector<string> result;
-  size_t begin=0, end=s.find(delim);
-  while (true) {
-    if (end == string::npos) {
+  size_t begin=0, end=s.find(delim);
+  while (true) {
+    if (end == string::npos) {
       result.push_back(string(s, begin, string::npos));
       break;
     }
@@ -348,21 +341,21 @@ vector<string> split(string s(string s, string delim) {
   vector<string> result;
-  size_t end=s.find(delim);
+  size_t end=s.find(delim);
   result.push_back(string(s, 0, end));
-  if (end != string::npos)
+  if (end != string::npos)
     result.push_back(string(s, end+SIZE(delim), string::npos));
   return result;
 }
 
-string trim(const string& s) {
+string trim(const string& s) {
   string::const_iterator first = s.begin();
-  while (first != s.end() && isspace(*first))
+  while (first != s.end() && isspace(*first))
     ++first;
-  if (first == s.end()) return "";
+  if (first == s.end()) return "";
 
   string::const_iterator last = --s.end();
-  while (last != s.begin() && isspace(*last))
+  while (last != s.begin() && isspace(*last))
     --last;
   ++last;
   return string(first, last);
@@ -370,22 +363,22 @@ string trim(const string& s:(before "End Includes")
 #include<vector>
-using std::vector;
+using std::vector;
 #include<list>
-using std::list;
+using std::list;
 #include<map>
-using std::map;
+using std::map;
 #include<set>
-using std::set;
+using std::set;
 #include<algorithm>
 
 #include<sstream>
-using std::istringstream;
-using std::ostringstream;
+using std::istringstream;
+using std::ostringstream;
 
 #include<fstream>
-using std::ifstream;
-using std::ofstream;
+using std::ifstream;
+using std::ofstream;
 
 #include"termbox/termbox.h"
 
@@ -397,8 +390,8 @@ using std::ofstream;
 //: Errors will be depth 0.
 //: Mu 'applications' will be able to use depths 1-100 as they like.
 //: Primitive statements will occupy 101-9989
-const int Initial_callstack_depth = 101;
-const int Max_callstack_depth = 9989;
+const int Initial_callstack_depth = 101;
+const int Max_callstack_depth = 9989;
 //: Finally, details of primitive mu statements will occupy depth 9990-9999 (more on that later as well)
 //:
 //: This framework should help us hide some details at each level, mixing
@@ -406,4 +399,3 @@ const int Max_callstack_depth = 9989