protected void AcceptListItem(RCToken token, string listTagName)
{
// Console.Out.WriteLine ("AcceptListItem({0}): '{1}'", _state, token.Text);
// Console.Out.WriteLine ("_parsingParagraph: {0}", _parsingParagraph);
// Console.Out.WriteLine ("_parsingList: {0}", _parsingList);
// Console.Out.WriteLine ("_blankLine: {0}", _blankLine);
MarkdownState oldState = _state;
_state = MarkdownState.ListItem;
if (_parsingList)
{
FinishRuns(false);
WrapLITextIfNeeded(oldState);
while (_names.Peek() != "li")
{
EndBlock();
}
EndBlock();
_parsingParagraph = false;
}
if (!_parsingList && oldState == MarkdownState.None)
{
_parsingList = true;
_name = listTagName;
StartBlock();
}
_name = "li";
// This may need to go onto the stack to do nested lists.
StartBlock();
}
public override RCValue Parse(RCArray <RCToken> tokens, out bool fragment, bool canonical)
{
_initialState = _state;
for (int i = 0; i < tokens.Count; ++i)
{
tokens[i].Type.Accept(this, tokens[i]);
}
fragment = false;
// Console.Out.WriteLine ("Done parsing. Doing cleanup ({0})", _state);
FinishQuote(true);
while (_values.Count > 0)
{
EndBlock();
}
if (_run.Length > 0)
{
_value = new RCBlock(_value, "", ":", new RCString(_run.ToString()));
}
else if (_initialState == MarkdownState.Link && _value == null)
{
_value = new RCBlock(null, "", ":", new RCString(""));
}
return(_value);
}
public override void AcceptMarkdownLiteralLink(RCToken token)
{
// Do not break out of a p for a link
FinishRuns(false);
if (_state == MarkdownState.None)
{
_name = "p";
StartBlock();
_parsingParagraph = true;
}
_state = MarkdownState.Link;
int openBracket = 0;
int closeBracket = token.Text.Length - 1;
int linkTextStart = openBracket + 1;
int linkTextLength = closeBracket - linkTextStart;
string linkText = token.Text.Substring(linkTextStart, linkTextLength);
_name = "a";
StartBlock();
RCBlock textBlock = new RCBlock("", ":", new RCString(linkText));
_value = new RCBlock(RCBlock.Empty, "text", ":", textBlock);
_value = new RCBlock(_value, "href", ":", new RCString(linkText));
EndBlock();
}
protected void UpdateTextRun(StringBuilder run, string text)
{
if (_state == MarkdownState.Paragraph ||
_state == MarkdownState.Em ||
_state == MarkdownState.Bold ||
_state == MarkdownState.Link ||
_state == MarkdownState.Blockquote ||
_state == MarkdownState.MaybeBR ||
_state == MarkdownState.ListItem)
{
run.Append(text);
}
else if (_state == MarkdownState.Newline1)
{
text = text.TrimStart();
if (_parsingParagraph || run.Length > 0)
{
run.Append(" ");
}
run.Append(text);
_state = MarkdownState.Paragraph;
}
else
{
run.Append(text);
}
if (text.EndsWith(" "))
{
_state = MarkdownState.MaybeBR;
}
else
{
_state = MarkdownState.Paragraph;
}
}
protected void FinishList()
{
if (_parsingList && _liLength <= 0 &&
_state != MarkdownState.Em &&
_state != MarkdownState.Bold &&
_state != MarkdownState.ListItem &&
_state != MarkdownState.Paragraph &&
_state != MarkdownState.Link)
{
while (true)
{
EndBlock();
string tag = _names.Peek();
if (tag == "ol" || tag == "ul")
{
EndBlock();
break;
}
}
// Console.Out.WriteLine ("Done parsing list");
_parsingList = false;
_parsingParagraph = false;
_state = MarkdownState.None;
}
}
public override void AcceptMarkdownContent(RCToken token)
{
// Console.Out.WriteLine ("AcceptMarkdownContent({0}): '{1}'", _state, token.Text);
// Console.Out.WriteLine ("_parsingParagraph: {0}", _parsingParagraph);
// Console.Out.WriteLine ("_parsingList: {0}", _parsingList);
// Console.Out.WriteLine ("_liLength: {0}", _liLength);
// Console.Out.WriteLine ("_blankLine: {0}", _blankLine);
string text = token.Text;
if (_state == MarkdownState.ListItem)
{
WrapLITextIfNeeded(_state);
}
if (_liLength > -1)
{
bool indentedlip = true;
for (int i = 0; i < _liLength; ++i)
{
if (i < text.Length && text[i] != ' ')
{
indentedlip = false;
}
}
if (indentedlip)
{
WrapLITextIfNeeded(_state);
}
}
FinishList();
if (_parsingList && _parsingParagraph &&
_blankLine && _state == MarkdownState.None)
{
EndBlock();
_parsingParagraph = false;
}
// _parsingParagraph should be sufficient, shouldn't need _run.Length check.
if ((!_parsingParagraph && _blankLine && _parsingList) ||
(!_parsingList && !_parsingParagraph && _run.Length == 0 &&
(_state == MarkdownState.None || _state == MarkdownState.Newline1)))
{
_state = MarkdownState.Paragraph;
_name = "p";
StartBlock();
_name = "";
_value = RCBlock.Empty;
text = text.TrimStart();
_parsingParagraph = true;
}
else if (_state == MarkdownState.Newline1 || _state == MarkdownState.MaybeBR)
{
text = text.TrimStart();
}
UpdateTextRun(_run, text);
}
protected void EndBlock()
{
AppendRun();
if (_values.Count > 0)
{
// ShowStack ("EndBlock");
RCBlock child = _value;
_name = _names.Pop();
_value = _values.Pop();
_state = _states.Pop();
_value = new RCBlock(_value, _name, ":", child);
_name = "";
// Console.Out.WriteLine (" EndBlock: _value: {0}", _value);
}
}
public override void AcceptMarkdownLink(RCToken token)
{
// Console.Out.WriteLine ("AcceptMarkdownLink: '{0}'", token.Text);
// Console.Out.WriteLine ("_state: " + _state);
if (_state == MarkdownState.None || _state == MarkdownState.Blockquote)
{
_name = "p";
StartBlock();
_parsingParagraph = true;
}
FinishRuns(false);
_state = MarkdownState.Link;
// [ will be at 1 in the case of ! img syntax
int openBracket = token.Text.IndexOf('[');
int closingBracket = token.Text.IndexOf(']');
int linkTextStart = openBracket + 1;
int linkTextLength = closingBracket - linkTextStart;
string linkText = token.Text.Substring(linkTextStart, linkTextLength);
int openingParen = closingBracket + 1;
int closingParen = token.Text.IndexOf(')', openingParen);
int firstChar = openingParen + 1;
string href = token.Text.Substring(firstChar, closingParen - firstChar);
AppendRun();
bool reentered;
RCBlock text = ParseEmbeddedRun(linkText, MarkdownState.Link, out reentered);
if (token.Text[0] == '[')
{
_name = "a";
StartBlock();
_value = new RCBlock(RCBlock.Empty, "text", ":", text);
_value = new RCBlock(_value, "href", ":", new RCString(href));
EndBlock();
}
else if (token.Text[0] == '!')
{
_name = "img";
StartBlock();
_value = new RCBlock(RCBlock.Empty, "src", ":", new RCString(href));
_value = new RCBlock(_value, "alt", ":", text);
EndBlock();
}
else
{
throw new Exception("Cannot parse link: " + token.Text);
}
}
public override void AcceptMarkdownBlockquote(RCToken token)
{
// Console.Out.WriteLine ("AcceptMarkdownBlockquote({0}): '{1}'", _state,
// token.Text);
int firstContent = -1;
int quoteLevel = 0;
for (int current = 0; current < token.Text.Length; ++current)
{
if (token.Text[current] != ' ' && token.Text[current] != '>')
{
firstContent = current;
break;
}
if (token.Text[current] == '>')
{
++quoteLevel;
}
}
if (firstContent < 0)
{
// It's a blank line - nothing to do
return;
}
int contentLength = token.Text.Length - firstContent;
string text = token.Text.Substring(firstContent, contentLength);
if (quoteLevel > _quoteLevel)
{
FinishQuote(false);
int levels = quoteLevel - _quoteLevel;
for (int level = 0; level < levels; ++level)
{
_state = MarkdownState.Paragraph;
_name = "blockquote";
StartBlock();
}
}
else if (quoteLevel < _quoteLevel)
{
FinishQuote(true);
}
_state = MarkdownState.Paragraph;
UpdateTextRun(_quoteRun, text);
_quoteRun.AppendLine();
_quoteLevel = quoteLevel;
}
protected RCBlock ParseEmbeddedRun(string text,
MarkdownState state,
out bool reentered)
{
_reentered = true;
RCArray <RCToken> tokens = new RCArray <RCToken> ();
_lexer.Lex(text, tokens);
MarkdownParser parser = new MarkdownParser();
parser._state = state;
bool fragment;
RCBlock result = (RCBlock)parser.Parse(tokens, out fragment, canonical: false);
reentered = parser._reentered;
return(result);
}
public override void AcceptMarkdownBeginBold(RCToken token)
{
// Console.Out.WriteLine ("AcceptMarkdownBeginBold: '{0}'", token.Text);
UpdateTextRun(_run, "");
AppendRun();
if (_parsingList && _blankLine)
{
_name = "p";
StartBlock();
_parsingParagraph = true;
}
_name = "strong";
StartBlock();
_name = "";
_value = RCBlock.Empty;
_state = MarkdownState.Bold;
}
protected void WrapLITextIfNeeded(MarkdownState oldState)
{
// Console.WriteLine(" WrapLITextIfNeeded ({0})", oldState);
// Console.Out.WriteLine (" _parsingParagraph: {0}", _parsingParagraph);
// Console.Out.WriteLine (" _parsingList: {0}", _parsingList);
// Console.Out.WriteLine (" _blankLine: {0}", _blankLine);
if (_parsingList && _blankLine && !_parsingParagraph)
{
// insert a new item
// Console.WriteLine(" WrapLITextIfNeeded ITS NEEDED! _value.Name: {0}",
// _value.Name);
if (_value.Name == "") // || _value.Name == "em" || _value.Name == "strong")
// Console.Out.WriteLine (" INSERTING A P");
{
_value = new RCBlock(RCBlock.Empty, "p", ":", _value);
}
}
}
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;
}