// Warning: zero automated tests
// Includes
#include "termbox/termbox.h"
#include <stdlib.h>
#define SIZE(X) (assert((X).size() < (1LL<<(sizeof(int)*8-2))), static_cast<int>((X).size()))
#include <assert.h>
#include <iostream>
using std::istream;
using std::ostream;
using std::iostream;
using std::cin;
using std::cout;
using std::cerr;
#include <iomanip>
#include <string.h>
#include <string>
using std::string;
#include <vector>
using std::vector;
#include <set>
using std::set;
#include <sstream>
using std::ostringstream;
#include <fstream>
using std::ifstream;
using std::ofstream;
#include <map>
using std::map;
#include <utility>
using std::pair;
// End Includes
// Types
struct trace_line {
string contents;
string label;
int depth; // 0 is 'sea level'; positive integers are progressively 'deeper' and lower level
trace_line(string c, string l, int d) {
contents = c;
label = l;
depth = d;
}
};
struct trace_stream {
vector<trace_line> past_lines;
};
enum search_direction { FORWARD, BACKWARD };
// End Types
// from http://stackoverflow.com/questions/152643/idiomatic-c-for-reading-from-a-const-map
template<typename T> typename T::mapped_type& get(T& map, typename T::key_type const& key) {
typename T::iterator iter(map.find(key));
assert(iter != map.end());
return iter->second;
}
template<typename T> typename T::mapped_type const& get(const T& map, typename T::key_type const& key) {
typename T::const_iterator iter(map.find(key));
assert(iter != map.end());
return iter->second;
}
template<typename T> typename T::mapped_type const& put(T& map, typename T::key_type const& key, typename T::mapped_type const& value) {
// map[key] requires mapped_type to have a zero-arg (default) constructor
map.insert(std::make_pair(key, value)).first->second = value;
return value;
}
template<typename T> bool contains_key(T& map, typename T::key_type const& key) {
return map.find(key) != map.end();
}
template<typename T> typename T::mapped_type& get_or_insert(T& map, typename T::key_type const& key) {
return map[key];
}
// Globals
trace_stream* Trace_stream = NULL;
ofstream Trace_file;
int Cursor_row = 0; // screen coordinate
set<int> Visible;
int Top_of_screen = 0; // trace coordinate
int Left_of_screen = 0; // trace coordinate
int Last_printed_row = 0; // screen coordinate
map<int, int> Trace_index; // screen row -> trace index
string Current_search_pattern = "";
search_direction Current_search_direction = FORWARD;
// End Globals
bool has_data(istream& in) {
return in && !in.eof();
}
void skip_whitespace_but_not_newline(istream& in) {
while (true) {
if (!has_data(in)) break;
else if (in.peek() == '\n') break;
else if (isspace(in.peek())) in.get();
else break;
}
}
void load_trace(const char* filename) {
ifstream tin(filename);
if (!tin) {
cerr << "no such file: " << filename << '\n';
exit(1);
}
Trace_stream = new trace_stream;
while (has_data(tin)) {
tin >> std::noskipws;
skip_whitespace_but_not_newline(tin);
if (!isdigit(tin.peek())) {
string dummy;
getline(tin, dummy);
continue;
}
tin >> std::skipws;
int depth;
tin >> depth;
string label;
tin >> label;
if (*--label.end() == ':') label.erase(--label.end());
string line;
getline(tin, line);
Trace_stream->past_lines.push_back(trace_line(line, label, depth));
}
cerr << "lines read: " << Trace_stream->past_lines.size() << '\n';
}
void refresh_screen_rows() { // Top_of_screen, Visible -> Trace_index
int screen_row = 0, index = 0;
Trace_index.clear();
for (screen_row = 0, index = Top_of_screen; screen_row < tb_height() && index < SIZE(Trace_stream->past_lines); ++screen_row, ++index) {
// skip lines without depth for now
while (!contains_key(Visible, index)) {
++index;
if (index >= SIZE(Trace_stream->past_lines)) goto done;
}
assert(index < SIZE(Trace_stream->past_lines));
put(Trace_index, screen_row, index);
}
done:;
}
void clear_line(int screen_row) { // -> screen
tb_set_cursor(0, screen_row);
for (int col = 0; col < tb_width(); ++col)
tb_print(' ', TB_WHITE, TB_BLACK);
tb_set_cursor(0, screen_row);
}
int read_key() {
tb_event event;
do {
tb_poll_event(&event);
} while (event.type != TB_EVENT_KEY);
return event.key ? event.key : event.ch;
}
int lines_hidden(int screen_row) {
assert(contains_key(Trace_index, screen_row));
if (!contains_key(Trace_index, screen_row+1))
return SIZE(Trace_stream