protected override void ParseInternal(string srcText, RTParsingContext context)
{
StringBuilder sb = new StringBuilder();
int index = SourceStartIndex;
ParsingState state = ParsingState.Neutral;
while (index < srcText.Length)
{
char currentChar = srcText[index];
switch (state)
{
case ParsingState.Neutral:
if (currentChar == EXPR_MARKER) state = ParsingState.CheckingMarker;
else sb.Append(currentChar);
break;
case ParsingState.CheckingMarker:
if (currentChar == EXPR_START)
{
index--;
goto EXIT_LOOP;
}
else if (currentChar == EXPR_END)
{
if (context.MarkerDepth == 0)
{
sb.Append(EXPR_MARKER).Append(EXPR_END);
state = ParsingState.Neutral;
}
else
{
index--;
goto EXIT_LOOP;
}
}
else if (currentChar == EXPR_MARKER)
{
sb.Append(EXPR_MARKER);
state = ParsingState.Neutral;
}
else
{
sb.Append(EXPR_MARKER).Append(currentChar);
state = ParsingState.Neutral;
}
break;
default:
throw new NotSupportedException();
}
index++;
}
if (state == ParsingState.CheckingMarker)
{
sb.Append(EXPR_MARKER);
}
EXIT_LOOP:
context.SourceEndIndex = index - 1;
_value = sb.ToString();
}
public void Parse(string srcText, int srcStartIndex, RTParsingContext context)
{
Contract.Requires(srcStartIndex >= 0);
Contract.Requires(srcStartIndex < srcText.Length);
Contract.Requires(context != null);
this.SourceStartIndex = srcStartIndex;
var existingErrors = context.Errors.Count;
ParseInternal(srcText, context);
if (context.Errors.Count == existingErrors)
this.CanExecute = true;
this.SourceEndIndex = context.SourceEndIndex;
}
protected override void ParseInternal(string srcText, RTParsingContext context)
{
int enteringDepth = context.MarkerDepth;
int index = this.SourceStartIndex;
if (enteringDepth > 0)
{
context.MarkerDepth++;
index += 2;
}
while (index < srcText.Length)
{
RTExpression expr;
MarkerType markerType = PeekMarker(srcText, index);
if (markerType == MarkerType.StartMarker)
{
expr = new RTFunctionList();
}
else if (markerType == MarkerType.EndMarker)
{
if (context.MarkerDepth > 0)
{
context.MarkerDepth--;
context.SourceEndIndex = index + 1;
break;
}
else
{
expr = new RTLiteral();
}
}
else
{
expr = new RTLiteral();
}
expr.Parse(srcText, index, context);
_items.Add(expr);
index = context.SourceEndIndex + 1;
}
if (enteringDepth != context.MarkerDepth)
{
context.MarkerDepth = enteringDepth; //restore from error
context.SourceEndIndex = index - 1;
context.Errors.Add(new RTParsingError(this.SourceStartIndex, context.SourceEndIndex, RTErrorCode.EndMarkerMissing, ErrorMessages.Expression_List_End_Marker_Missing));
}
}
protected override void ParseInternal(string srcText, RTParsingContext context)
{
Debug.Assert(PeekMarker(srcText, SourceStartIndex) == MarkerType.StartMarker);
int enteringDepth = context.MarkerDepth;
context.MarkerDepth++;
int index = this.SourceStartIndex + 2;
while (index < srcText.Length)
{
RTExpression expr;
if (Char.IsWhiteSpace(srcText[index]))
{
index++;
continue;
}
MarkerType markerType = PeekMarker(srcText, index);
if (markerType == MarkerType.StartMarker)
{
expr = new RTExpressionList();
}
else if (markerType == MarkerType.None)
{
expr = new RTFunction();
}
else //== EndMarker
{
context.MarkerDepth--;
context.SourceEndIndex = index + 1;
break;
}
expr.Parse(srcText, index, context);
_items.Add(expr);
index = context.SourceEndIndex + 1;
}
if (enteringDepth != context.MarkerDepth)
{
context.MarkerDepth = enteringDepth; //restore from error
context.SourceEndIndex = index - 1;
context.Errors.Add(new RTParsingError(this.SourceStartIndex, context.SourceEndIndex, RTErrorCode.EndMarkerMissing, ErrorMessages.Function_List_End_Marker_Missing));
}
}
private void Init()
{
if (_options != null)
{
RTParsingContext context = new RTParsingContext(_factory);
var exprList = new RTExpressionList();
exprList.Parse(_templateExpr, 0, context); //parse should not throw an exception
_interpreter = exprList;
_options = null;
_templateExpr = null;
if (!_interpreter.CanExecute)
{
_parsingException = new RTParsingException(context.Errors, ErrorMessages.Template_Parsing_Error);
}
}
if (_parsingException != null) throw _parsingException;
}
private void Init()
{
if (_mergeOptions != null)
{
RTParsingContext context = new RTParsingContext(_factory);
var exprList = new RTExpressionList();
exprList.Parse(_mergeExpr, 0, context);
_interpreter = exprList;
_mergeOptions = null; //not needed anymore
_mergeExpr = null;
if (!_interpreter.CanExecute)
{
_parsingException = new RTParsingException(context.Errors, ErrorMessages.Post_Parsing_Error);
}
}
if (_parsingException != null) throw _parsingException;
}
/// <summary> /// Need to return source end index with parsing context. /// Source start index is passed in through parsing context. /// </summary> /// <param name="srcText"></param> /// <param name="context"></param> protected abstract void ParseInternal(string srcText, RTParsingContext context);
public void Parse(string srcText, RTParsingContext context)
{
Parse(srcText, 0, context);
}
protected override void ParseInternal(string srcText, RTParsingContext context)
{
bool flagExit = false;
ParsingState state = ParsingState.Start;
int index = SourceStartIndex;
while (!flagExit)
{
int tokenStartIndex = index;
TokenType token = ReadToken(srcText, ref index);
if (token == TokenType.NONE) break;
string tokenValue = srcText.Substring(tokenStartIndex, index - tokenStartIndex);
switch (state)
{
case ParsingState.Start:
if (token == TokenType.WHITESPACE)
{
//ignore
}
else if (token == TokenType.OPEN_BRACKET)
{
state = ParsingState.FuncName;
}
else
{
context.Errors.Add(new RTParsingError(tokenStartIndex, index - 1, RTErrorCode.OpenBracketMissing, ErrorMessages.Function_Open_Bracket_Missing));
flagExit = true;
}
break;
case ParsingState.Invalid:
if (token == TokenType.CLOSE_BRACKET) //exit at nearest closing bracket
{
flagExit = true;
}
break;
case ParsingState.FuncName:
if (token == TokenType.SYMBOL)
{
this.Name = tokenValue;
state = ParsingState.FuncArg;
}
else if (token == TokenType.IDENTIFIER)
{
bool isvalid = CheckIdentifier(tokenValue);
if (isvalid)
{
this.Name = tokenValue;
state = ParsingState.FuncArg;
}
else
{
state = ParsingState.Invalid;
context.Errors.Add(new RTParsingError(tokenStartIndex, index - 1, RTErrorCode.InvalidIdentifier, string.Format(ErrorMessages.Function_Invalid_Arg_Identifier, tokenValue)));
}
}
else
{
state = ParsingState.Invalid;
context.Errors.Add(new RTParsingError(tokenStartIndex, index - 1, RTErrorCode.InvalidFunctionName, string.Format(ErrorMessages.Function_Name_Missing, token)));
if (token == TokenType.CLOSE_BRACKET)
flagExit = false;
}
break;
case ParsingState.FuncArgNegative:
if (token == TokenType.WHITESPACE)
{
this.Args.Add(new RTVariable("-"));
}
else if (token == TokenType.NUMBER)
{
double temp;
if (double.TryParse(tokenValue, out temp))
{
this.Args.Add(-temp);
}
else
{
context.Errors.Add(new RTParsingError(tokenStartIndex, index - 1, RTErrorCode.InvalidNumber, string.Format(ErrorMessages.Function_Invalid_Arg_Number, tokenValue)));
}
}
else
{
context.Errors.Add(new RTParsingError(tokenStartIndex, index - 1, RTErrorCode.InvalidToken, string.Format(ErrorMessages.Function_Invalid_Arg, tokenValue)));
if (token == TokenType.CLOSE_BRACKET)
flagExit = false;
}
state = ParsingState.FuncArg;
break;
case ParsingState.FuncArg:
switch (token)
{
case TokenType.WHITESPACE://ignore
break;
case TokenType.CLOSE_BRACKET:
flagExit = true;
break;
case TokenType.OPEN_BRACKET:
RTFunction func = new RTFunction();
func.Parse(srcText, tokenStartIndex, context);
index = context.SourceEndIndex + 1;
this.Args.Add(func);
break;
case TokenType.TRUE:
this.Args.Add(true);
break;
case TokenType.FALSE:
this.Args.Add(false);
break;
case TokenType.NULL:
this.Args.Add(null);
break;
case TokenType.INVALID:
context.Errors.Add(new RTParsingError(tokenStartIndex, index - 1, RTErrorCode.InvalidToken, string.Format(ErrorMessages.Function_Invalid_Arg, tokenValue)));
break;
case TokenType.NUMBER:
double temp;
if (double.TryParse(tokenValue, out temp))
{
this.Args.Add(temp);
}
else
{
context.Errors.Add(new RTParsingError(tokenStartIndex, index - 1, RTErrorCode.InvalidNumber, string.Format(ErrorMessages.Function_Invalid_Arg_Number, tokenValue)));
}
break;
case TokenType.SYMBOL:
if (tokenValue == "-")
{
state = ParsingState.FuncArgNegative;
}
else
{
this.Args.Add(new RTVariable(tokenValue));
}
break;
case TokenType.IDENTIFIER:
bool isValid = CheckIdentifier(tokenValue);
if (isValid)
{
this.Args.Add(new RTVariable(tokenValue));
}
else
{
context.Errors.Add(new RTParsingError(tokenStartIndex, index - 1, RTErrorCode.InvalidIdentifier, string.Format(ErrorMessages.Function_Invalid_Arg_Identifier, tokenValue)));
}
break;
case TokenType.EXPR_START:
RTExpression expr = new RTExpressionList();
expr.Parse(srcText, tokenStartIndex, context);
index = context.SourceEndIndex + 1;
Args.Add(expr);
break;
default:
throw new NotSupportedException("Unknown token type.");
}
break;
default:
throw new NotSupportedException("Unknow Function Parsing State.");
}
}
if (!flagExit)
{
context.Errors.Add(new RTParsingError(this.SourceStartIndex, index - 1, RTErrorCode.EndBraketMissing, ErrorMessages.Function_End_Bracket_Missing));
}
context.SourceEndIndex = index - 1;
//resolve metadata
this.Metadata = this.Name == null ? null : context.MetadataFactory.GetMetadata(this.Name);
if (this.Metadata == null)
{
this.Metadata = context.MetadataFactory.GetMetadata(RTSysSymbols.APPLY); //the apply symbol
this.Args.Insert(0, new RTVariable(this.Name));
this.Name = RTSysSymbols.APPLY;
}
this.Metadata.NormalizeArgs(this.Args);
#if DEBUG
_src = srcText.Substring(this.SourceStartIndex, context.SourceEndIndex - this.SourceStartIndex + 1);
#endif
}