internal string GetPredicateFullPath(ExprItem exprItem)
{
ExprLeaf leaf = exprItem as ExprLeaf;
if (leaf != null)
{
if (leaf.ReferenceType.IndexOf("path", StringComparison.InvariantCultureIgnoreCase) >= 0)
{
return(leaf.Item.ToString());
}
}
ExprUnaryOperator unarayOperand = exprItem as ExprUnaryOperator;
if (unarayOperand != null)
{
ExprItem operand = unarayOperand.Operand;
return(GetPredicateFullPath(operand));
}
PathExpr pathExpr = exprItem as PathExpr;
if (pathExpr != null)
{
return(pathExpr.Path);
}
return(null);
}
private static string GetCriteriaType(Match match, out object criteria)
{
string type = "String";
string stringCriteria = match.Groups["stringCriteria"].Value;
if (!string.IsNullOrEmpty(stringCriteria))
{
type = ExprItem.GetTypeValue(stringCriteria);
criteria = stringCriteria;
return(type);
}
else
{
string intCriteria = match.Groups["intCriteria"].Value;
if (!string.IsNullOrEmpty(intCriteria))
{
type = "Integer";
int intValue = int.MinValue;
if (!int.TryParse(intCriteria, out intValue))
{
throw new ApplicationException(intValue + " is not a valid integer.");
}
criteria = intValue;
return(type);
}
string doubleCriteria = match.Groups["doubleCriteria"].Value;
if (!string.IsNullOrEmpty(doubleCriteria))
{
type = "Double";
double doubleValue = double.MinValue;
if (!double.TryParse(doubleCriteria, out doubleValue))
{
throw new ApplicationException(doubleCriteria + " is not a valid double value.");
}
criteria = doubleValue;
return(type);
}
string boolCriteria = match.Groups["boolCriteria"].Value;
if (!string.IsNullOrEmpty(boolCriteria))
{
type = "Boolean";
bool boolValue = true;
if (!bool.TryParse(boolCriteria.ToString(), out boolValue))
{
throw new ApplicationException(boolCriteria + " is not a valid boolean value.");
}
criteria = boolValue;
return(type);
}
criteria = stringCriteria;
return(type);
}
}
internal static ExprItem ExprItem(string typeName)
{
DesignByContract.Check.Require(!string.IsNullOrEmpty(typeName), string.Format(CommonStrings.XMustNotBeNullOrEmpty, "typeName"));
ExprItem exprItem = null;
switch (typeName)
{
case "EXPR_LEAF":
exprItem = new ExprLeaf();
break;
case "EXPR_UNARY_OPERATOR":
exprItem = new ExprUnaryOperator();
break;
case "EXPR_BINARY_OPERATOR":
exprItem = new ExprBinaryOperator();
break;
default:
throw new NotSupportedException("type not supported: " + typeName);
}
DesignByContract.Check.Ensure(exprItem != null, "exprItem must not be null.");
return(exprItem);
}
internal string GetValueCriteriaByPath(ExprItem exprItem, string requiredPath)
{
ExprLeaf leaf = exprItem as ExprLeaf;
ExprBinaryOperator binary = exprItem as ExprBinaryOperator;
if (binary != null)
{
switch (binary.Operator.Value)
{
case OperatorKind.op_eq:
case OperatorKind.op_ne:
{
string path = GetPredicateFullPath(binary.LeftOperand);
if (path != null && path.EndsWith(requiredPath, StringComparison.InvariantCultureIgnoreCase))
{
ExprLeaf rightOperand = binary.RightOperand as ExprLeaf;
if (rightOperand == null)
{
throw new ApplicationException("rightOperand must be typeof ExprLeaf when the leftOperand is name/value path.");
}
if (!rightOperand.ReferenceType.Equals("constraint"))
{
throw new NotSupportedException(rightOperand.ReferenceType + "rightOperand.ReferenceType is not supported.");
}
return(rightOperand.Item.ToString());
}
return(null);
}
case OperatorKind.op_or:
case OperatorKind.op_and:
case OperatorKind.op_not:
ExprItem left = binary.LeftOperand;
ExprItem right = binary.RightOperand;
string nameValue = GetValueCriteriaByPath(right, requiredPath);
if (nameValue != null)
{
return(nameValue);
}
nameValue = GetValueCriteriaByPath(left, requiredPath);
return(nameValue);
default:
return(null);
}
}
return(null);
}
List<ExprItem> regulars = new List<ExprItem>(); /* Opcionális kifejezés kezdete-> o:: */
/* ***************************************** */
public Section(string sname,bool opt,List<string> rules)
{
SectName = sname;
optional = opt;
foreach (string s in rules)
{
Regex r = new Regex(@"^(?<opti>o[r]?::)?(?<other>.+)$");
Match m = r.Match(s);
ExprItem eItem = new ExprItem();
eItem.expr = m.Groups["other"].Value;
eItem.optional = m.Groups["opti"].Value.ToString() == "o::";
regulars.Add(eItem);
}
}
private static TlaExpr TranslateToTlaExpr(this exprSeq expr, AutomatonParsingContext ctx)
{
if (expr.exprItems.Length != expr.boolOperators.Length + 1)
{
throw new ApplicationException();
}
var items = new ExprItem[expr.exprItems.Length + expr.boolOperators.Length];
items[0] = new ExprItem(expr.exprItems[0].Translate(ctx));
for (int i = 0, j = 1; i < expr.boolOperators.Length; i++, j += 2)
{
items[j + 0] = new ExprItem(_opsByStr[expr.boolOperators[i].strings.First()]);
items[j + 1] = new ExprItem(expr.exprItems[i + 1].Translate(ctx));
}
return(TranslateExprPart(items, 0, items.Length));
}
protected void ValidateBase(ExprItem exprItem)
{
Invariant(!string.IsNullOrEmpty(exprItem.Type), string.Format(
CommonStrings.XMustNotBeNull, "ExprItem.Type"));
}
protected void Validate(ExprItem exprItem)
{
if (exprItem == null)
{
throw new ArgumentNullException(string.Format(
CommonStrings.XMustNotBeNull, "exprItem"));
}
const string methodName = "Validate";
try
{
System.Reflection.MethodInfo method = this.GetType().GetMethod(methodName,
System.Reflection.BindingFlags.ExactBinding | System.Reflection.BindingFlags.NonPublic
| System.Reflection.BindingFlags.Instance, Type.DefaultBinder,
new Type[] { exprItem.GetType() },
new System.Reflection.ParameterModifier[0]);
if (method != null)
{
if (method != lastExprItemMethodRead || exprItem != lastExprItem)
{
lastExprItemMethodRead = method;
lastExprItem = exprItem;
method.Invoke(this, new Object[] { exprItem });
}
else
{
string message = string.Format(CommonStrings.LoopingMethodTerminated,
methodName, exprItem.GetType().ToString());
System.Diagnostics.Debug.WriteLine(message);
throw new ApplicationException(message);
}
}
else
{
string message = string.Format(CommonStrings.MethodXNotImplementedForParamTypeY,
methodName, exprItem.GetType().ToString());
System.Diagnostics.Debug.WriteLine(message);
throw new ApplicationException(message);
}
}
catch (Exception ex)
{
if (ex.InnerException != null)
{
if (ex.InnerException is ApplicationException && ex.InnerException.InnerException != null &&
ex.InnerException.Message == ex.InnerException.InnerException.Message)
{
throw new ApplicationException(ex.InnerException.Message, ex.InnerException.InnerException);
}
else
{
throw new ApplicationException(ex.InnerException.Message, ex.InnerException);
}
}
else
{
throw new ApplicationException(ex.Message, ex);
}
}
}
