parser.d

/** Count the indent level and return where the indent level stops in "i"
 * A tab is counted as one indent.
 * Params:
 * i = the index to start looking from. This is mutated
 * by reference to indicate the index the last index
 * was.
 * spaces_per_indent = the number of spaces to treat as one indent
 */
int count_indents(ref int i, string input, int spaces_per_indent=4) {
 int nspaces = 0;
 if (i == input.length || !(input[i] == ' ' || input[i] == '\t')) {
 return 0;
 }
 for (; i < input.length; ++i) {
 switch (input[i]) {
 case ' ': nspaces++; break;
 case '*': nspaces++; break;
 case '\t': nspaces += spaces_per_indent; break;
 // Commented out makes it only accept "-"
 //case '-': return nspaces / spaces_per_indent;
 case '\n': nspaces = 0; break;
 //default : return 0;
 default : return nspaces / spaces_per_indent;
 }
 }
 return nspaces / spaces_per_indent;
}
unittest {
 int i;
 assert(count_indents(i = 0, " - hi") == 1);
 assert(count_indents(i = 0, "Foo") == 0);
 assert(count_indents(i = 0, " - hi") == 2);
 assert(count_indents(i = 0, "\t - hey") == 1);
}
void doNothing(T)(T _=null) {}
/** A streaming parser for Markdown trees. Emits a stream of parsing events. 
 * Params:
 * ParseEventHandler = struct that handles a stream of parsing events.
 * See [ExampleParseEventHandler] for an example.
 * deleStart = function that is called with the return value of
 * the ParseEventHandler's start(). Defaults to 
 * doNothing
 * deleEnd = function that is called with the return value of
 * the ParseEventHandler's end(). Defaults to 
 * doNothing
 * These are all compile-time (template) parameters, thus the compiler will
 * inline functions into generated code.
 */
void parse(ParseEventHandler,
 alias deleStart=doNothing,
 alias deleEnd=doNothing,
 bool relaxed=false,
 Args...)
 (string input, int spaces_per_indent, string title, Args args) {
 import std.traits;
 ParseEventHandler handler = ParseEventHandler(args);
 //const initial_indent_level = 
 int current_indent_level;
 //BitType current_bits;
 //BitType[] stack;
 int line_content_start_index;
 int line_start_index;
 // Workwround for void not being a parameter type
 void emitBlockStart(string nodeContent) {
 static if (is(ReturnType!(handler.start) == void)) {
 handler.start(nodeContent);
 deleStart();
 } else deleStart(handler.start(nodeContent));
 }
 void emitBlockEnd() {
 static if (is(ReturnType!(handler.end) == void)) {
 handler.end();
 deleEnd();
 } else deleEnd(handler.end());
 }
 emitBlockStart(title);
 for (int i = 0; i < input.length; ++i) {
 // emit end when on same or lower indent level, number based on difference
 // start on new lines
 switch (input[i]) {
 case '\n':
 //stack[0] & current_bits;
 // FIXME: Start and end based on "-"
 const nodeContent = input[line_start_index..i];
 import std.stdio;
 emitBlockStart(nodeContent);
 i++;
 line_start_index = i;
 int new_indent_level =
 count_indents(i, input, spaces_per_indent);
 line_content_start_index = i;
 const extraEndings = i == input.length ? 0 : 1;
 foreach (_;
 0..current_indent_level - new_indent_level + extraEndings) {
 emitBlockEnd();
 }
 if (relaxed && new_indent_level > current_indent_level + 1) {
 foreach (_; 0..new_indent_level - current_indent_level - 1)
 {
 emitBlockStart("");
 }
 }
 current_indent_level = new_indent_level;
 break;
 case '[':
 break;
 // Skip across multiline constructs to prevent
 // detect_indent
 case '`':
 if (input[i+1] == '`' && input[i+2] == '`') {
 // Skip 3 at a time for efficiency
 // TODO: SIMD this and/or PGO it
 for (i += 3; i < input.length; ++i) {
 if (input[i-2] == '`' && 
 input[i-1] == '`' && 
 input[i-0] == '`') {
 break;
 }
 }
 }
 break;
 default: break;
 }
 }
 if (line_content_start_index != input.length) {
 emitBlockStart(input[line_start_index .. input.length]);
 }
 for (int i = 0; i < current_indent_level + 1; ++i) {
 emitBlockEnd();
 }
 // End again because we started for the title
 emitBlockEnd();
}
/// Test the stream of parser events
unittest {
 import std.range, std.array;
 struct ExampleParseEventHandler {
 string start(string text) {
 return "START" ~ text;
 }
 string end() {
 return "END";
 }
 }
 string sample = "- ab\n\t- b\nhello\n\tworld\n\tfoo";
 // A trailing newline should not affect ther esult
 foreach (useTrailingNewline; [false, true]) {
 string result;
 parse!(ExampleParseEventHandler, s => result ~= s, s => result ~= s)
 (sample ~ (useTrailingNewline ? "\n" : ""), 4, "Title");
 import std.stdio;
 debug writeln(result);
 assert(result == 
 "STARTTitleSTART- abSTART\t- bENDENDSTARThelloSTART\tworldENDSTART\tfooENDENDEND"
 );
 }
}
struct A {

}
private struct WithConstructor {
 string[] member;
 this(string[] arg, A a) {
 member = arg;
 }
 void start(string text) {
 }
 void end() {
 }
 }
unittest {
 A a;
 parse!(WithConstructor)
 ("Test", 4, "Title", ["arg"], a);
}
unittest {
 import std.stdio;
 struct ExampleParseEventHandler {
 string start(string text) {
 return "<div>" ~ text;
 }
 string end() {
 return "</div>";
 }
 }
 string sample =
`a
 b
c
 d`;
 string result;
 parse!(ExampleParseEventHandler, s => result ~= s, s => result ~= s, true)
 (sample, 1, "Title");
 writeln(result);
 assert(result == "<div>Title<div>a<div><div> b</div></div></div><div>c<div><div><div> d</div></div></div></div></div>");
}
struct ConvertToXMLEventHandler {
 string start(string text) {
 return "<block>" ~ text;
 }
 string end() {
 return "</block>";
 }
}
/*struct ConvertToOPMLEventHandler {
 string start(string text) {
 // todo: escpae
 return `<outline text=` ~ text;
 }
 string end() {
 return `</outline>`;
 }
}*/