protected bool SyntaxCheckParameters()
{
PatternToken lToken = GetCurrentToken();
if (lToken == PatternToken.CLOSE_PARA)
{
return(true); // no parameters
}
if (!SyntaxCheckParameter())
{
return(false);
}
lToken = GetCurrentToken();
if (lToken == PatternToken.CLOSE_PARA)
{
return(true);
}
if (lToken != PatternToken.COMMA)
{
return(SetErrorMessage("Expected ',': " + CompileErrorLocation()));
}
NextToken();
return(SyntaxCheckParameters());
}
protected bool SyntaxCheckFunction()
{
PatternFunction lFunction = GetCurrentFunction();
if (lFunction == null)
{
return(SetErrorMessage("Unknown Function: " + CompileErrorLocation()));
}
NextToken();
PatternToken lToken = GetCurrentToken();
if (lToken != PatternToken.OPEN_PARA)
{
return(SetErrorMessage("Expected ')': " + CompileErrorLocation()));
}
NextToken();
if (!SyntaxCheckParameters())
{
return(false);
}
lToken = GetCurrentToken();
if (lToken != PatternToken.CLOSE_PARA)
{
return(SetErrorMessage("Expected ')': " + CompileErrorLocation()));
}
NextToken();
return(true);
}
public bool SyntaxCheck()
{
ClearErrorMessages();
mPosition = 0;
if (PatternOperands.Count == 0)
{
return(true);
}
if (!SyntaxCheckExpression())
{
return(false);
}
PatternToken lToken = GetCurrentToken();
if (lToken != PatternToken.END)
{
return(SetErrorMessage("Unexpected token: " + CompileErrorLocation()));
}
return(true);
}
public static PatternCode Scan(string code)
{
PatternCode lPatternCode = new PatternCode();
int lPosition = 0;
PatternToken lPreviousToken = PatternToken.UNKNOWN;
// tokenize code
while (lPosition < code.Length)
{
string lTokenString = ReadTokenString(code, ref lPosition);
PatternToken lToken = GetToken(lTokenString, lPreviousToken);
// "*" could also be a variable
if ((lToken == PatternToken.MULTIPLY) && (lPreviousToken == PatternToken.COMMA || lPreviousToken == PatternToken.OPEN_PARA))
{
lToken = PatternToken.VARIABLE;
}
int lParameterCount = (lToken == PatternToken.FUNCTION) ? GetParameterCount(code, lPosition) : 0;
PatternOperand patternOperand = new PatternOperand(lToken, lTokenString, lParameterCount);
if (lToken == PatternToken.UNKNOWN)
{
lPatternCode.SetErrorMessage("Unknown Token: " + lTokenString.ToString());
return(lPatternCode);
}
lPatternCode.Add(patternOperand);
lPreviousToken = lToken;
}
return(lPatternCode);
}
void HandleText(PatternToken t)
{
StringBuilder reToAppend = inHeader ? headerRe : bodyRe;
reToAppend.AppendFormat("{0} # fixed text '{1}'{2}", Regex.Escape(t.Value), t.Value, Environment.NewLine);
ConcatToBody(GetCSharpStringLiteral(t.Value));
}
IEnumerable <PatternToken> TokenizePattern(string pattern)
{
int idx = 0; // Current position in the pattern
for (;;)
{
Match m = patternParserRe.Match(pattern, idx);
if (m.Success)
{
// A specifier is found
if (m.Index > idx) // Yield the text before the specifier found (if any)
{
PatternToken txt1 = new PatternToken();
txt1.Type = PatternTokenType.Text;
txt1.Value = pattern.Substring(idx, m.Index - idx);
yield return(txt1);
}
if (m.Groups[1].Value != "") // If %% was found, yield single '%'
{
PatternToken txt2 = new PatternToken();
txt2.Type = PatternTokenType.Text;
txt2.Value = "%";
yield return(txt2);
}
else // A 'normal' specifier was found. Fill up the structure and yield it.
{
PatternToken spec;
spec.Type = PatternTokenType.Specifier;
spec.RightPaddingFlag = m.Groups[2].Value != "";
spec.Padding = m.Groups[3].Value != "" ? int.Parse(m.Groups[3].Value) : 0;
spec.Trim = m.Groups[4].Value != "" ? int.Parse(m.Groups[4].Value) : 0;
spec.Value = m.Groups[5].Value;
spec.Argument = m.Groups[6].Value;
yield return(spec);
}
// Move current position to the end of the specifier found
idx = m.Index + m.Length;
}
else
{
if (idx < pattern.Length) // Yield the rest of the pattern if any
{
PatternToken txt3 = new PatternToken();
txt3.Type = PatternTokenType.Text;
txt3.Value = pattern.Substring(idx);
yield return(txt3);
}
// Stop parsing
break;
}
}
}
private PatternToken GetRootPatternToken([NotNull] RootModel rootModel)
{
Assert.ArgumentNotNull(rootModel, "rootModel");
if (_rootPatternToken == null)
{
_rootPatternToken = WildcardParser.ParseWildcardString(_textToHighlight, rootModel);
}
return(_rootPatternToken);
}
private PatternToken GetSubstituteWithPatternToken([NotNull] RootModel rootModel)
{
Assert.ArgumentNotNull(rootModel, "rootModel");
if (_rootSubstituteWithPatternToken == null)
{
_rootSubstituteWithPatternToken = WildcardParser.ParseWildcardString(SubstituteWith, rootModel);
}
return(_rootSubstituteWithPatternToken);
}
protected bool SyntaxCheckParameter()
{
PatternToken lToken = GetCurrentToken();
if (lToken == PatternToken.VARIABLE)
{
NextToken();
return(true);
}
return(SyntaxCheckExpression());
}
protected int EvaulateFunction()
{
PatternFunction lFunction = GetCurrentFunction();
NextToken();
NextToken();
PatternFunctionParameters <int> lPatternFunctionParameters = new PatternFunctionParameters <int>();
while (true)
{
PatternToken lToken = GetCurrentToken();
int lInt = GetTokenInteger(); // in case this is needed later
char lVariable = GetTokenVariable(); // in case this is needed later
NextToken();
if (lToken == PatternToken.COMMA)
{
continue;
}
if (lToken == PatternToken.CLOSE_PARA)
{
break;
}
if (lToken == PatternToken.INTEGER)
{
lPatternFunctionParameters.Add(lInt);
}
else if (lToken == PatternToken.VARIABLE)
{
Coordinate lCoordinate = OriginPoint + (Pattern.GetLetterLocation(lVariable) - Pattern.Origin).Transform(Transform);
lPatternFunctionParameters.Add(Board.Coord.At(lCoordinate.X, lCoordinate.Y));
}
else
{
lPatternFunctionParameters.Add(EvaulateExpression());
}
}
// Call function
return(lFunction(Board, Player, lPatternFunctionParameters));
}
public PatternOperand(PatternToken token, string tokenString, int paramCount)
{
Token = token;
Source = tokenString; // used for debugging
if (token == PatternToken.INTEGER)
Integer = Convert.ToInt32(tokenString);
else if (token == PatternToken.VARIABLE)
Variable = tokenString[0];
else if (token == PatternToken.UNKNOWN)
return;
else if (token == PatternToken.FUNCTION)
{
Integer = paramCount;
Function = PatternFunctions.GetFunction(tokenString, paramCount);
}
}
private bool EvalulateCondition(PatternProcessingParameters parameters, PatternToken token)
{
if (token.Type == TokenType.TAG_BRANCH_CHANCE)
{
var chance = int.Parse(TrimTag(1, token.Value));
return(_random.Next(100) < chance);
}
else if (token.Type == TokenType.TAG_BRANCH_CONTEXT)
{
return(parameters.Context.Contains(TrimTag(1, token.Value)));
}
else if (token.Type == TokenType.TAG_BRANCH_VARIABLE)
{
return(parameters.Variables.ContainsKey(TrimTag(1, token.Value)));
}
throw new PatternParseException("Unhandled condition type: " + token.Type);
}
static PatternToken GetToken(string token, PatternToken previousToken)
{
if (string.IsNullOrEmpty(token))
{
return(PatternToken.UNKNOWN);
}
TokenCharacterType lType = GetCharType(token[0]);
if (lType == TokenCharacterType.UNKNOWN)
{
return(PatternToken.UNKNOWN);
}
if (lType == TokenCharacterType.WORD)
{
if (token.Length == 1)
{
return(PatternToken.VARIABLE); // variables are one character only (at least in this language)
}
else
{
return(PatternToken.FUNCTION); // functions are always more than on character (in this language)
}
}
if (lType == TokenCharacterType.NUMBER)
{
return(PatternToken.INTEGER);
}
if ((lType == TokenCharacterType.STAR) && (previousToken == PatternToken.COMMA || previousToken == PatternToken.OPEN_PARA))
{
return(PatternToken.VARIABLE);
}
if (PatternTokens.Instance.ContainsKey(token))
{
return(PatternTokens.Instance[token]);
}
return(PatternToken.UNKNOWN);
}
public PatternOperand(PatternToken token, string tokenString, int paramCount)
{
Token = token;
Source = tokenString; // used for debugging
if (token == PatternToken.INTEGER)
{
Integer = Convert.ToInt32(tokenString);
}
else if (token == PatternToken.VARIABLE)
{
Variable = tokenString[0];
}
else if (token == PatternToken.UNKNOWN)
{
return;
}
else if (token == PatternToken.FUNCTION)
{
Integer = paramCount;
Function = PatternFunctions.GetFunction(tokenString, paramCount);
}
}
static int GetParameterCount(string code, int position)
{
int lParamCnt = 0;
int lLevel = 0;
int lPosition = position;
// skip past the first open para.
while (lPosition < code.Length)
{
string lTokenString = ReadTokenString(code, ref lPosition);
PatternToken lToken = GetToken(lTokenString);
if (lToken == PatternToken.OPEN_PARA)
{
break;
}
}
while (lPosition < code.Length)
{
string lTokenString = ReadTokenString(code, ref lPosition);
PatternToken lToken = GetToken(lTokenString);
if (lLevel == 0)
{
if (lParamCnt == 0)
{
if ((lToken != PatternToken.UNKNOWN) && (lToken != PatternToken.CLOSE_PARA))
{
lParamCnt++;
}
}
if (lToken == PatternToken.COMMA)
{
lParamCnt++;
}
else
if (lToken == PatternToken.OPEN_PARA)
{
lLevel++;
}
else
if (lToken == PatternToken.CLOSE_PARA)
{
return(lParamCnt);
}
}
else
if (lToken == PatternToken.OPEN_PARA)
{
lLevel++;
}
else
if (lToken == PatternToken.CLOSE_PARA)
{
lLevel--;
}
}
return(-1); // something went wrong
}
public PatternOperand(PatternToken token)
{
Token = token;
}
protected bool SyntaxCheckExpression()
{
PatternToken lToken = GetCurrentToken();
if (lToken == PatternToken.COMMA)
{
return(SetErrorMessage("Unexpected ',': " + CompileErrorLocation()));
}
if (lToken == PatternToken.CLOSE_PARA)
{
return(SetErrorMessage("Unexpected ')': " + CompileErrorLocation()));
}
if (lToken == PatternToken.FUNCTION)
{
if (!SyntaxCheckFunction())
{
return(false);
}
}
else if (lToken == PatternToken.OPEN_PARA)
{
NextToken();
if (!SyntaxCheckExpression())
{
return(false);
}
lToken = GetCurrentToken();
if (lToken != PatternToken.CLOSE_PARA)
{
return(SetErrorMessage("Expected ')': " + CompileErrorLocation()));
}
NextToken();
}
else if (lToken == PatternToken.INTEGER) // || (lToken == PatternToken.REAL))
{
NextToken();
}
else
{
return(SetErrorMessage("Unexpected token: " + CompileErrorLocation()));
}
PatternToken lNextToken = GetCurrentToken();
if ((lNextToken == PatternToken.EQUAL) ||
(lNextToken == PatternToken.NOT_EQUAL) ||
(lNextToken == PatternToken.GATHER_THAN) ||
(lNextToken == PatternToken.LESS_THAN) ||
(lNextToken == PatternToken.GATHER_THAN_OR_EQUAL) ||
(lNextToken == PatternToken.LESS_THAN_OR_EQUAL) ||
(lNextToken == PatternToken.AND) ||
(lNextToken == PatternToken.MULTIPLY) ||
(lNextToken == PatternToken.OR) ||
(lNextToken == PatternToken.PLUS) ||
(lNextToken == PatternToken.MINUS))
{
NextToken();
return(SyntaxCheckExpression());
}
if ((lNextToken == PatternToken.END) || (lNextToken == PatternToken.CLOSE_PARA))
{
return(true);
}
return(SetErrorMessage("Expected: " + CompileErrorLocation()));
}
protected int EvaulateExpression()
{
int lLeft = TRUE;
int lRight = TRUE;
while (true)
{
PatternToken lLeftToken = GetCurrentToken();
if (lLeftToken == PatternToken.OPEN_PARA)
{
NextToken();
lLeft = EvaulateExpression();
}
else
if (lLeftToken == PatternToken.INTEGER)
{
lLeft = GetTokenInteger();
NextToken();
}
else if (lLeftToken == PatternToken.FUNCTION)
{
lLeft = EvaulateFunction();
}
else
{
return(0); // ERROR!!!
}
PatternToken lOtoken = GetCurrentToken();
NextToken();
if ((lOtoken == PatternToken.CLOSE_PARA) || (lOtoken == PatternToken.END))
{
return(lLeft); // immediate close (no comparison)
}
// short cut boolean evaluation
if (((lOtoken == PatternToken.AND) && (lLeft == TRUE)) || ((lOtoken == PatternToken.OR) && (lLeft == FALSE)))
{
int lPCnt = 1;
while (lPCnt > 0)
{
PatternToken lToken = GetCurrentToken();
NextToken();
if (lToken == PatternToken.CLOSE_PARA)
{
lPCnt--;
}
else if (lToken == PatternToken.OPEN_PARA)
{
lPCnt++;
}
else if (lToken == PatternToken.END)
{
break;
}
}
return(lLeft);
}
lRight = EvaulateExpression();
switch (lOtoken)
{
case PatternToken.EQUAL: lLeft = (lLeft == lRight) ? TRUE : FALSE; break;
case PatternToken.NOT_EQUAL: lLeft = (lLeft != lRight) ? TRUE : FALSE; break;
case PatternToken.GATHER_THAN: lLeft = (lLeft > lRight) ? TRUE : FALSE; break;
case PatternToken.LESS_THAN: lLeft = (lLeft < lRight) ? TRUE : FALSE; break;
case PatternToken.GATHER_THAN_OR_EQUAL: lLeft = (lLeft >= lRight) ? TRUE : FALSE; break;
case PatternToken.LESS_THAN_OR_EQUAL: lLeft = (lLeft <= lRight) ? TRUE : FALSE; break;
case PatternToken.AND: lLeft = ((lLeft == TRUE) && (lRight == TRUE)) ? TRUE : FALSE; break;
case PatternToken.OR: lLeft = ((lLeft == TRUE) || (lRight == TRUE)) ? TRUE : FALSE; break;
case PatternToken.PLUS: lLeft = (lLeft + lRight); break;
case PatternToken.MINUS: lLeft = (lLeft - lRight); break;
case PatternToken.MULTIPLY: lLeft = (lLeft * lRight); break;
default: return(FALSE); // ERROR!
}
return(lLeft);
}
}
private StringBuilder ProcessSubPattern(StringBuilder resultBuilder,
PatternProcessingParameters parameters, PatternToken token)
{
var namelistName = TrimTag(1, token.Value);
var namelist = _namelistSource.GetNamelist(namelistName);
if (namelist == null)
{
throw new PatternParseException(string.Format("No namelist matching {0} found.",
namelistName));
}
var fragments = namelist.FragmentsForContext(parameters.Context);
if (fragments.Count < 1)
{
throw new PatternParseException(string.Format(
"No fragments found for namelist: {0} and contexts: {1}",
namelistName,
string.Join(", ", parameters.Context.ToArray())));
}
var r = _random.Next(fragments.Count);
var fragment = fragments[r];
var subParams = new PatternProcessingParameters(fragment)
{
CapitalizationScheme = parameters.CapitalizationScheme,
Context = parameters.Context,
UniqueCheck = parameters.UniqueCheck,
Variables = parameters.Variables
};
var result = Process(subParams);
return(resultBuilder.Append(result));
}
static PatternToken GetToken(string token, PatternToken previousToken)
{
if (string.IsNullOrEmpty(token))
return PatternToken.UNKNOWN;
TokenCharacterType lType = GetCharType(token[0]);
if (lType == TokenCharacterType.UNKNOWN)
return PatternToken.UNKNOWN;
if (lType == TokenCharacterType.WORD)
if (token.Length == 1)
return PatternToken.VARIABLE; // variables are one character only (at least in this language)
else
return PatternToken.FUNCTION; // functions are always more than on character (in this language)
if (lType == TokenCharacterType.NUMBER)
return PatternToken.INTEGER;
if ((lType == TokenCharacterType.STAR) && (previousToken == PatternToken.COMMA || previousToken == PatternToken.OPEN_PARA))
return PatternToken.VARIABLE;
if (PatternTokens.Instance.ContainsKey(token))
return PatternTokens.Instance[token];
return PatternToken.UNKNOWN;
}
private StringBuilder PerformSubstitution(StringBuilder resultBuilder,
PatternProcessingParameters parameters, PatternToken token)
{
if (token.Type == TokenType.TAG_SUB_FRAGMENT)
{
var namelistName = TrimTag(0, token.Value);
var namelist = _namelistSource.GetNamelist(namelistName);
if (namelist == null)
{
throw new PatternParseException(string.Format("No namelist matching {0} found.",
namelistName));
}
var fragments = namelist.FragmentsForContext(parameters.Context);
if (fragments.Count < 1)
{
throw new PatternParseException(string.Format(
"No fragments found for namelist: {0} and contexts: {1}",
namelistName,
string.Join(", ", parameters.Context.ToArray())));
}
var r = _random.Next(fragments.Count);
var fragment = fragments[r];
if (parameters.CapitalizationScheme == CapitalizationScheme.BY_FRAGMENT)
{
fragment = char.ToUpper(fragment[0]) + fragment.Substring(1);
}
return(resultBuilder.Append(fragment));
}
else if (token.Type == TokenType.TAG_SUB_VARIABLE)
{
var variableName = TrimTag(1, token.Value);
if (!parameters.Variables.ContainsKey(variableName))
{
throw new PatternParseException("Variable expected but not provided: " + variableName);
}
return(resultBuilder.Append(parameters.Variables[variableName]));
}
throw new PatternParseException("Unhandled substitution type: " + token.Type);
}
protected string Source; // used for debugging
#endregion Fields
#region Constructors
public PatternOperand()
{
Token = PatternToken.UNKNOWN;
}
public PatternOperand(PatternToken token)
{
Token = token;
}
void HandleSpecifier(PatternToken t)
{
string captureName;
string re;
string outputFieldName = null;
string outputFieldCode = null;
string outputFieldCodeType = null;
switch (t.Value)
{
case "a":
case "appdomain":
captureName = "AppDomain";
re = @".*";
break;
case "c":
case "logger":
captureName = "Logger";
re = @"[\w\.]+";
break;
case "aspnet-cache":
case "aspnet-context":
case "aspnet-request":
case "aspnet-session":
var m = Regex.Match(t.Value, @"(\w+)-(\w+)");
captureName =
CapitalizeFirstLetter(m.Groups[1].Value) +
CapitalizeFirstLetter(m.Groups[2].Value) +
CapitalizeFirstLetter(t.Argument);
re = @".*";
break;
case "C":
case "class":
case "type":
captureName = "Class";
re = @".*"; // * because caller location might not be accessible
break;
case "d":
case "date":
case "utcdate":
captureName = "Time";
string fmt;
switch (t.Argument)
{
case "ABSOLUTE":
fmt = "HH:mm:ss,fff";
break;
case "DATE":
fmt = "dd MMM yyyy HH:mm:ss,fff";
break;
case "ISO8601":
case "":
fmt = "yyyy-MM-dd HH:mm:ss,fff";
break;
default:
fmt = t.Argument;
break;
}
re = GetDateRe(fmt);
outputFieldName = "Time";
outputFieldCode = string.Format("TO_DATETIME(Time, {0})", GetCSharpStringLiteral(fmt));
break;
case "newline":
case "n":
captureName = "NL";
re = @"\n|\r\n";
break;
case "exception":
captureName = "Exception";
re = @".*";
inHeader = false;
break;
case "file":
case "F":
captureName = "File";
// insert " with Format() because otherwise I would have to remove @ and escape the re heavily
re = string.Format(@"[^\*\?\{0}\<\>\|]*", '"'); // [...]* because caller location might not be accessible
break;
case "identity":
case "u":
captureName = "Identity";
re = @"[\w\\\.]*";
break;
case "location":
case "l":
captureName = "Location";
re = @".*"; // * because caller location might not be accessible
break;
case "line":
case "L":
captureName = "Line";
re = @"\d*"; // * because caller location might not be accessible
break;
case "p":
case "level":
captureName = "Level";
re = @"DEBUG|INFO|WARN|ERROR|FATAL";
outputFieldName = "Severity";
outputFieldCode = @"
switch (Level)
{
case ""WARN"":
return Severity.Warning;
case ""ERROR"":
case ""FATAL"":
return Severity.Error;
default:
return Severity.Info;
}";
outputFieldCodeType = "function";
break;
case "message":
case "m":
captureName = "Message";
inHeader = false;
re = ".*";
break;
case "method":
case "M":
captureName = "Method";
re = ".*";
break;
case "mdc":
case "property":
case "P":
case "X":
case "properties":
captureName = "Prop";
re = ".*";
break;
case "r":
case "timestamp":
captureName = "Timestamp";
re = @"\d+";
break;
case "thread":
case "t":
captureName = "Thread";
re = ".+";
outputFieldName = "Thread";
outputFieldCode = "Thread";
break;
case "username":
case "w":
captureName = "User";
re = @"[\w\\\.]+";
break;
case "x":
case "ndc":
captureName = "NDC";
re = @".+";
break;
case "stacktrace":
case "stacktracedetail":
captureName = "Stacktrace";
re = @".+";
break;
default:
return;
}
captureName = RegisterCaptureName(captureName);
StringBuilder reToAppend = inHeader ? headerRe : bodyRe;
string paddingString = null;
if (t.Padding != 0)
{
paddingString = string.Format(@"\ {{0,{0}}}", t.Padding);
}
if (paddingString != null && !t.RightPaddingFlag)
{
reToAppend.Append(paddingString);
}
reToAppend.AppendFormat("(?<{0}>{1})", captureName, re);
if (paddingString != null && t.RightPaddingFlag)
{
reToAppend.Append(paddingString);
}
reToAppend.AppendFormat(" # field '{0}'{1}", t.Value, Environment.NewLine);
if (outputFieldName != null)
{
OutputField f = GetOutputField(outputFieldName);
// First, check if the code is empty yet.
// The code may have already been initialized. That may happen if
// there are several specifiers with the same name and that produce
// an output field. We want to take in use only the first such specifier.
if (f.Code.Length == 0)
{
f.Code.Append(outputFieldCode);
f.CodeType = outputFieldCodeType;
// Time field souldn't go to the body because
// it can be displayed later in the log view (Show Time... in content menu)
if (outputFieldName == "Time")
{
return;
}
}
}
if (captureName == "Message")
{
ConcatToBody(captureName);
}
}
protected string Source; // used for debugging
public PatternOperand()
{
Token = PatternToken.UNKNOWN;
}
