public override void AcceptEndOfLine(RCToken token)
{
}
public override object Parse(RCLexer lexer, RCToken token)
{
return(token.Text);
}
public override decimal ParseDecimal(RCLexer lexer, RCToken token)
{
return(decimal.Parse(ExtractNumber(token)));
}
public override long ParseLong(RCLexer lexer, RCToken token)
{
return(long.Parse(ExtractNumber(token)));
}
public override object Parse(RCLexer lexer, RCToken token)
{
return(ParseString(lexer, token));
}
public override double ParseDouble(RCLexer lexer, RCToken token)
{
return(double.Parse(ExtractNumber(token)));
}
public override object Parse(RCLexer lexer, RCToken token)
{
return(null);
}
public override void Accept(RCParser parser, RCToken token)
{
parser.AcceptString(token);
}
public override void Accept(RCParser parser, RCToken token)
{
parser.AcceptBlock(token);
}
public override string ParseString(RCLexer lexer, RCToken token)
{
// Need to handle xml escape characters here, this is incomplete.
return(token.Text);
}
public override RCToken TryParseToken(string code,
int start,
int index,
int line,
RCToken
previous)
{
string token;
if (code[start] == '{' || code[start] == '}')
{
token = code.Substring(start, 1);
return(new RCToken(token, this, start, index, line, 0));
}
int end = start;
if (code[end] == '[')
{
++end;
while (code[end] == '?')
{
++end;
}
if (1 < end - start)
{
// This is needed to handle the special case of [??]
// I think that should be valid syntax just like [] and {}
if (code[end] == ']')
{
end = start + ((end - start + 1) / 2);
}
goto END;
}
while (code[end] == '!')
{
++end;
}
if (1 < end - start)
{
goto END;
}
return(null);
}
else if (code[end] == '!')
{
while (code[end] == '!')
{
++end;
}
if (code[end] == ']')
{
++end;
goto END;
}
return(null);
}
else if (code[end] == '?')
{
while (code[end] == '?')
{
++end;
}
if (code[end] == ']')
{
++end;
goto END;
}
return(null);
}
else
{
return(null);
}
END:
token = code.Substring(start, end - start);
return(new RCToken(token, this, start, index, line, 0));
}
public override void AcceptLogEntryHeader(RCToken token)
{
if (_bot != null)
{
if (_builder.Length > 0)
{
_document = _builder.ToString();
}
AppendEntry();
}
int current = 0;
_time = RCTokenType.Time.TryParseToken(token.Text, current, 0, 0, null);
if (_time != null)
{
current += _time.Text.Length;
// skip the single space. Do not validate.
// This requires log files to only use single spaces between header values.
++current;
}
_bot = RCTokenType.Number.TryParseToken(token.Text, current, 0, 0, null);
if (_bot != null)
{
current += _bot.Text.Length;
}
++current;
_fiber = RCTokenType.Number.TryParseToken(token.Text, current, 0, 0, null);
if (_fiber != null)
{
current += _fiber.Text.Length;
}
++current;
_module = RCTokenType.Name.TryParseToken(token.Text, current, 0, 0, null);
if (_module != null)
{
current += _module.Text.Length;
}
++current;
_instance = RCTokenType.Number.TryParseToken(token.Text, current, 0, 0, null);
if (_instance != null)
{
current += _instance.Text.Length;
}
++current;
_event = RCTokenType.Name.TryParseToken(token.Text, current, 0, 0, null);
if (_event != null)
{
current += _event.Text.Length;
}
++current;
if (current <= token.Text.Length)
{
_message = token.Text.Substring(current);
}
else
{
_message = null;
}
_builder.Clear();
}
protected void AppendEntry()
{
if (_time != null)
{
_result.WriteCell("time", null, _time.ParseTime(_lexer));
}
if (_bot != null)
{
_result.WriteCell("bot", null, _bot.ParseLong(_lexer));
}
else
{
_result.WriteCell("bot", null, (long)-1);
}
if (_fiber != null)
{
_result.WriteCell("fiber", null, _fiber.ParseLong(_lexer));
}
else
{
_result.WriteCell("fiber", null, (long)-1);
}
if (_module != null)
{
_result.WriteCell("module", null, _module.Text);
}
else
{
_result.WriteCell("module", null, "");
}
if (_instance != null)
{
_result.WriteCell("instance", null, _instance.ParseLong(_lexer));
}
else
{
_result.WriteCell("instance", null, (long)-1);
}
if (_event != null)
{
_result.WriteCell("event", null, _event.Text);
}
else
{
_result.WriteCell("event", null, "");
}
if (_message != null)
{
_result.WriteCell("message", null, _message);
}
if (_document != null)
{
_result.WriteCell("document", null, _document);
}
_result.Axis.Write();
// Reset everything for the next log entry.
_time = null;
_bot = null;
_fiber = null;
_module = null;
_instance = null;
_event = null;
_message = null;
_document = null;
}
public override void AcceptXmlContent(RCToken token)
{
_text = new RCString(token.Text);
}
public override RCToken TryParseToken(string code,
int start,
int index,
int line,
RCToken
previous)
{
if (previous == null)
{
return(null);
}
// we have to count the question marks in the previous token.
if (previous.Type != RCTokenType.Block)
{
return(null);
}
if (!(previous.Text.StartsWith("[?") || previous.Text.EndsWith("!]")))
{
return(null);
}
int lines = 0;
int marks = 0;
for (int i = 1; i < previous.Text.Length; ++i)
{
++marks;
}
for (int end = start; end < code.Length; ++end)
{
if (code[end] == '[')
{
int look = end + 1;
int reps = 0;
while (code[look] == '!')
{
++reps;
if (reps == marks)
{
string token = code.Substring(start, end - start);
return(new RCToken(token, this, start, index, line, lines));
}
++look;
}
}
else if (code[end] == '?')
{
int look = end + 1;
int reps = 1;
while (code[look] == '?')
{
++reps;
++look;
}
if (reps == marks && code[look] == ']')
{
string token = code.Substring(start, end - start);
return(new RCToken(token, this, start, index, line, lines));
}
}
else if (code[end] == '\n')
{
++lines;
}
}
return(null);
}
public override void AcceptXmlDeclaration(RCToken token)
{
}
public override void Accept(RCParser parser, RCToken token)
{
parser.AcceptContent(token);
}
public override string ParseString(RCLexer lexer, RCToken token)
{
string undelim = token.Text.Substring(1, token.Text.Length - 2);
return(UnescapeControlChars(undelim, '"'));
}
public override string ParseString(RCLexer lexer, RCToken token)
{
// Need to handle xml escape characters.
// Need to do some stuff here with the whitespace, could be a little involved...
return(token.Text);
}
public override void Accept(RCParser parser, RCToken token)
{
parser.AcceptNumber(token);
}
public override void AcceptEndOfLine(RCToken token)
{
// Console.Out.WriteLine ("AcceptEndOfLine({0})", _state);
// Console.Out.WriteLine (" _parsingParagraph: {0}", _parsingParagraph);
// Console.Out.WriteLine (" _parsingList: {0}", _parsingList);
if (token.Index == 0)
{
return;
}
if (_state == MarkdownState.Newline1)
{
if (_parsingList)
{
AppendRun();
_blankLine = true;
_state = MarkdownState.None;
}
else if (_quoteRun.Length > 0)
{
FinishQuote(true);
EndBlock();
_quoteLevel = 0;
_parsingParagraph = false;
_state = MarkdownState.None;
}
else
{
EndBlock();
_parsingParagraph = false;
_state = MarkdownState.None;
}
}
else if (_state == MarkdownState.MaybeBR)
{
if (_quoteRun.Length > 0)
{
_quoteRun.Append("\n");
}
if (_run.Length >= 2)
{
if (_run[_run.Length - 1] != ' ')
{
return;
}
if (_run[_run.Length - 2] != ' ')
{
return;
}
_run.Remove(_run.Length - 2, 2);
_run.Append("\n");
}
}
// else if (_state == MarkdownState.Paragraph)
// {
// AppendRun ();
// WrapLITextIfNeeded (_state);
// _state = MarkdownState.Newline1;
// }
else
{
_state = MarkdownState.Newline1;
}
_liLength = -1;
}
public override float ParseFloat(RCLexer lexer, RCToken token)
{
return(float.Parse(ExtractNumber(token)));
}
public override void AcceptMarkdownEndItalic(RCToken token)
{
// Console.Out.WriteLine ("AcceptMarkdownEndItalic: '{0}'", token.Text);
EndBlock();
}
public override int ParseInt(RCLexer lexer, RCToken token)
{
return(int.Parse(ExtractNumber(token)));
}
public override void AcceptMarkdownULItem(RCToken token)
{
AcceptListItem(token, "ul");
}
public abstract void AcceptName(object state, RCToken token);
public override void Accept(RCParser parser, RCToken token)
{
parser.AcceptSeparator(token);
}
