private static ExpressionState AppendExpression(ExpressionTemplate template, StringBuilder result, ExpressionState state, string expr)
{
if (result.Length == 0)
{
switch (state)
{
case ExpressionState.None:
case ExpressionState.HasAnd:
result.Append(expr);
state = ExpressionState.None;
break;
case ExpressionState.HasAnd | ExpressionState.HasNot:
case ExpressionState.HasNot:
result.Append(template.Not).Append(expr);
state = ExpressionState.None;
break;
case ExpressionState.HasOr:
case ExpressionState.HasOr | ExpressionState.HasNot:
throw new ClrPlusException("Invalid Conditional Expression (starts with 'or' operator?) ");
}
}
else
{
switch (state)
{
case ExpressionState.None:
case ExpressionState.HasNot:
throw new ClrPlusException("Invalid Conditional Expression (missing comparison before value) ");
case ExpressionState.HasAnd:
result.Append(template.And).Append(expr);
state = ExpressionState.None;
break;
case ExpressionState.HasAnd | ExpressionState.HasNot:
result.Append(template.AndNot).Append(expr);
state = ExpressionState.None;
break;
case ExpressionState.HasOr:
result.Append(template.Or).Append(expr);
state = ExpressionState.None;
break;
case ExpressionState.HasOr | ExpressionState.HasNot:
result.Append(template.OrNot).Append(expr);
state = ExpressionState.None;
break;
}
}
return(state);
}
private string GenerateExpression(string projectName, string expression, ExpressionTemplate template, List <Pivot> pivotsUsed)
{
private string GenerateExpression(string projectName, string expression, ExpressionTemplate template)
{
#endif
var theresult = _expressionCache.GetCachedAnswer(() => {
if (expression.IndexOf("$(") > -1)
{
// skip the whole parsing, we know this is a MSBuild expression
return(expression);
}
var result = new StringBuilder();
var rxResult = ExpressionRx.Match(expression);
if (rxResult.Success)
{
var state = ExpressionState.None;
foreach (var item in rxResult.Groups[1].Captures.Cast <Capture>().Select(each => each.Value.Trim()).Where(each => !string.IsNullOrEmpty(each)))
{
switch (item[0])
{
case '!':
if (state >= ExpressionState.HasNot)
{
throw new ClrPlusException("Invalid expression. (may not state ! on same item more than once)");
}
state = state | ExpressionState.HasNot;
continue;
case '&':
case ',':
case '\\':
case '/':
if (state > ExpressionState.HasOperator)
{
throw new ClrPlusException("Invalid expression. (May not state two operators in a row)");
}
state = state | ExpressionState.HasAnd;
continue;
case '|':
case '+':
if (state > ExpressionState.HasOperator)
{
throw new ClrPlusException("Invalid expression. (May not state two operators in a row)");
}
state = state | ExpressionState.HasOr;
continue;
case '(':
if (item.EndsWith(")"))
{
// parse nested expression.
#if USE_DYNAMIC_CRAP
state = AppendExpression(template, result, state, template.Container.format(GenerateExpression(projectName, item.Substring(1, item.Length - 2), template, pivotsUsed)));
#else
state = AppendExpression(template, result, state, template.Container.format(GenerateExpression(projectName, item.Substring(1, item.Length - 2), template)));
#endif
continue;
}
throw new ClrPlusException("Mismatched '(' in expression");
default:
if (!WordRx.IsMatch(item))
{
throw new ClrPlusException("Invalid characters in expression");
}
// otherwise, it's the word we're looking for.
//
string choice;
Pivot pivot;
if (!GetChoice(item, out choice, out pivot))
{
throw new ClrPlusException("Unmatched configuration choice '{0}".format(item));
}
#if USE_DYNAMIC_CRAP
if (!pivotsUsed.Contains(pivot))
{
pivotsUsed.Add(pivot);
}
#endif
state = AppendExpression(template, result, state, template.Comparison(projectName, choice, pivot));
break;
}
}
}
// Event<Verbose>.Raise("Pivots.GenerateExpression", "result [{0}]", result.ToString());
return(result.ToString());
}, projectName, expression, template);
#if USE_DYNAMIC_CRAP
_canonicalExpressions.GetOrAdd(expression, () => new List <string>()).Add(theresult);
var pU = _pivotsUsedCache.GetCachedAnswer(() => pivotsUsed.ToArray(), expression);
if (pivotsUsed.Count == 0)
{
pivotsUsed.AddRange(pU);
}
#endif
return(theresult);
}
public string Expression()
{
return(ExpressionTemplate.Replace("row", Row.ToString()).Replace("column", Column.ToString()));
}
public void ErrorsAreReported(string input, string error)
{
Assert.False(ExpressionTemplate.TryParse(input, null, null, out _, out var actual));
Assert.Equal(error, actual);
}
//JAVA TO C# CONVERTER WARNING: 'final' parameters are ignored unless the option to convert to C# 7.2 'in' parameters is selected:
//ORIGINAL LINE: public static Statement put(final ExpressionTemplate target, final Lookup<FieldReference> field, final ExpressionTemplate expression)
public static Statement Put(ExpressionTemplate target, Lookup <FieldReference> field, ExpressionTemplate expression)
{
return(new StatementAnonymousInnerClass3(target, field, expression));
}
//JAVA TO C# CONVERTER WARNING: 'final' parameters are ignored unless the option to convert to C# 7.2 'in' parameters is selected:
//ORIGINAL LINE: public static Statement returns(final ExpressionTemplate expression)
public static Statement Returns(ExpressionTemplate expression)
{
return(new StatementAnonymousInnerClass2(expression));
}
//JAVA TO C# CONVERTER WARNING: 'final' parameters are ignored unless the option to convert to C# 7.2 'in' parameters is selected:
//ORIGINAL LINE: static Statement expression(final ExpressionTemplate expression)
internal static Statement Expression(ExpressionTemplate expression)
{
return(new StatementAnonymousInnerClass(expression));
}