public string VoicePhrases(string sep)
{
List <Tuple <string, ConditionEntry.MatchType> > ret = actionfiles.ReturnValuesOfSpecificConditions("VoiceInput", new List <ConditionEntry.MatchType>()
{
ConditionEntry.MatchType.MatchSemicolonList, ConditionEntry.MatchType.MatchSemicolon
}); // need these to decide
string s = "";
foreach (var vp in ret)
{
BaseUtils.StringCombinations sb = new BaseUtils.StringCombinations();
sb.ParseString(vp.Item1);
s += String.Join(",", sb.Permutations.ToArray()) + sep;
}
return(s);
}
public string VoicePhrases(string sep)
{
var ret = actionfiles.ReturnSpecificConditions(ActionEventEDList.onVoiceInput.TriggerName, "VoiceInput", new List <ConditionEntry.MatchType>()
{
ConditionEntry.MatchType.MatchSemicolonList, ConditionEntry.MatchType.MatchSemicolon
}); // need these to decide
string s = "";
foreach (var vp in ret)
{
BaseUtils.StringCombinations sb = new BaseUtils.StringCombinations();
sb.ParseString(vp.Item2.MatchString);
s += String.Join(",", sb.Permutations.ToArray()) + sep;
}
return(s);
}
static public bool?CheckConditions(List <Condition> fel, Variables values, out string errlist, out ErrorClass errclass, List <Condition> passed = null, Functions cf = null)
{
errlist = null;
errclass = ErrorClass.None;
bool?outerres = null;
foreach (Condition fe in fel) // find all values needed
{
bool?innerres = null;
foreach (ConditionEntry f in fe.fields)
{
bool matched = false;
if (f.matchtype == ConditionEntry.MatchType.AlwaysTrue || f.matchtype == ConditionEntry.MatchType.AlwaysFalse)
{
if (f.itemname.Length == 0 || f.itemname.Equals("Condition", StringComparison.InvariantCultureIgnoreCase)) // empty (legacy) or
{
if (f.matchtype == ConditionEntry.MatchType.AlwaysTrue)
{
matched = true; // matched, else if false, leave as false.
}
}
else
{
errlist += "AlwaysFalse/True does not have on the left side the word 'Condition'";
errclass = ErrorClass.ExprFormatError;
innerres = false;
break;
}
}
else
{
string leftside = null;
Functions.ExpandResult er = Functions.ExpandResult.NoExpansion;
if (cf != null) // if we have a string expander, try the left side
{
er = cf.ExpandString(f.itemname, out leftside);
if (er == Functions.ExpandResult.Failed) // stop on error
{
errlist += leftside; // add on errors..
innerres = false; // stop loop, false
break;
}
}
if (f.matchtype == ConditionEntry.MatchType.IsPresent) // these use f.itemname without any expansion
{
if (leftside == null || er == Functions.ExpandResult.NoExpansion) // no expansion, must be a variable name
{
leftside = values.Qualify(f.itemname); // its a straight variable name, allow any special formatting
}
if (values.Exists(leftside) && values[leftside] != null)
{
matched = true;
}
}
else if (f.matchtype == ConditionEntry.MatchType.IsNotPresent)
{
if (leftside == null || er == Functions.ExpandResult.NoExpansion) // no expansion, must be a variable name
{
leftside = values.Qualify(f.itemname); // its a straight variable name, allow any special formatting
}
if (!values.Exists(leftside) || values[leftside] == null)
{
matched = true;
}
}
else
{
if (er == Functions.ExpandResult.NoExpansion) // no expansion, must be a variable name
{
string qualname = values.Qualify(f.itemname);
leftside = values.Exists(qualname) ? values[qualname] : null; // then lookup.. lookup may also be null if its a pre-def
if (leftside == null)
{
errlist += "Variable '" + qualname + "' does not exist" + Environment.NewLine;
errclass = ErrorClass.LeftSideVarUndefined;
innerres = false;
break; // stop the loop, its a false
}
}
string rightside;
if (cf != null) // if we have a string expander, pass it thru
{
er = cf.ExpandString(f.matchstring, out rightside);
if (er == Functions.ExpandResult.Failed) // if error, abort
{
errlist += rightside; // add on errors..
innerres = false; // stop loop, false
break;
}
}
else
{
rightside = f.matchstring;
}
if (f.matchtype == ConditionEntry.MatchType.DateBefore || f.matchtype == ConditionEntry.MatchType.DateAfter)
{
DateTime tmevalue, tmecontent;
if (!DateTime.TryParse(leftside, System.Globalization.CultureInfo.CreateSpecificCulture("en-US"), System.Globalization.DateTimeStyles.None, out tmevalue))
{
errlist += "Date time not in correct format on left side" + Environment.NewLine;
errclass = ErrorClass.LeftSideBadFormat;
innerres = false;
break;
}
else if (!DateTime.TryParse(rightside, System.Globalization.CultureInfo.CreateSpecificCulture("en-US"), System.Globalization.DateTimeStyles.None, out tmecontent))
{
errlist += "Date time not in correct format on right side" + Environment.NewLine;
errclass = ErrorClass.RightSideBadFormat;
innerres = false;
break;
}
else
{
if (f.matchtype == ConditionEntry.MatchType.DateBefore)
{
matched = tmevalue.CompareTo(tmecontent) < 0;
}
else
{
matched = tmevalue.CompareTo(tmecontent) >= 0;
}
}
}
else if (f.matchtype == ConditionEntry.MatchType.Equals)
{
matched = leftside.Equals(rightside, StringComparison.InvariantCultureIgnoreCase);
}
else if (f.matchtype == ConditionEntry.MatchType.EqualsCaseSensitive)
{
matched = leftside.Equals(rightside);
}
else if (f.matchtype == ConditionEntry.MatchType.NotEqual)
{
matched = !leftside.Equals(rightside, StringComparison.InvariantCultureIgnoreCase);
}
else if (f.matchtype == ConditionEntry.MatchType.NotEqualCaseSensitive)
{
matched = !leftside.Equals(rightside);
}
else if (f.matchtype == ConditionEntry.MatchType.Contains)
{
matched = leftside.IndexOf(rightside, StringComparison.InvariantCultureIgnoreCase) >= 0;
}
else if (f.matchtype == ConditionEntry.MatchType.ContainsCaseSensitive)
{
matched = leftside.Contains(rightside);
}
else if (f.matchtype == ConditionEntry.MatchType.DoesNotContain)
{
matched = leftside.IndexOf(rightside, StringComparison.InvariantCultureIgnoreCase) < 0;
}
else if (f.matchtype == ConditionEntry.MatchType.DoesNotContainCaseSensitive)
{
matched = !leftside.Contains(rightside);
}
else if (f.matchtype == ConditionEntry.MatchType.IsOneOf)
{
StringParser p = new StringParser(rightside);
List <string> ret = p.NextQuotedWordList();
if (ret == null)
{
errlist += "IsOneOf value list is not in a optionally quoted comma separated form" + Environment.NewLine;
errclass = ErrorClass.RightSideBadFormat;
innerres = false;
break; // stop the loop, its a false
}
else
{
matched = ret.Contains(leftside, StringComparer.InvariantCultureIgnoreCase);
}
}
else if (f.matchtype == ConditionEntry.MatchType.MatchSemicolon)
{
string[] list = rightside.Split(';').Select(x => x.Trim()).ToArray(); // split and trim
matched = list.Contains(leftside.Trim(), StringComparer.InvariantCultureIgnoreCase); // compare, trimmed, case insensitive
}
else if (f.matchtype == ConditionEntry.MatchType.MatchCommaList)
{
StringCombinations sc = new StringCombinations(',');
sc.ParseString(rightside); // parse, give all combinations
matched = sc.Permutations.Contains(leftside.Trim(), StringComparer.InvariantCultureIgnoreCase); // compare, trimmed, case insensitive
}
else if (f.matchtype == ConditionEntry.MatchType.MatchSemicolonList)
{
StringCombinations sc = new StringCombinations(';');
sc.ParseString(rightside); // parse, give all combinations
matched = sc.Permutations.Contains(leftside.Trim(), StringComparer.InvariantCultureIgnoreCase); // compare, trimmed, case insensitive
}
else if (f.matchtype == ConditionEntry.MatchType.AnyOfAny)
{
StringParser l = new StringParser(leftside);
List <string> ll = l.NextQuotedWordList();
StringParser r = new StringParser(rightside);
List <string> rl = r.NextQuotedWordList();
if (ll == null || rl == null)
{
errlist += "AnyOfAny value list is not in a optionally quoted comma separated form on both sides" + Environment.NewLine;
errclass = ErrorClass.RightSideBadFormat;
innerres = false;
break; // stop the loop, its a false
}
else
{
foreach (string s in ll) // for all left strings
{
if (rl.Contains(s, StringComparer.InvariantCultureIgnoreCase)) // if right has it..
{
matched = true; // matched and break
break;
}
}
}
}
else if (f.matchtype == ConditionEntry.MatchType.IsEmpty)
{
matched = leftside.Length == 0;
}
else if (f.matchtype == ConditionEntry.MatchType.IsNotEmpty)
{
matched = leftside.Length > 0;
}
else if (f.matchtype == ConditionEntry.MatchType.IsTrue || f.matchtype == ConditionEntry.MatchType.IsFalse)
{
int inum = 0;
if (leftside.InvariantParse(out inum))
{
matched = (f.matchtype == ConditionEntry.MatchType.IsTrue) ? (inum != 0) : (inum == 0);
}
else
{
errlist += "True/False value is not an integer on left side" + Environment.NewLine;
errclass = ErrorClass.LeftSideBadFormat;
innerres = false;
break;
}
}
else
{
double fnum = 0, num = 0;
if (!leftside.InvariantParse(out num))
{
errlist += "Number not in correct format on left side" + Environment.NewLine;
errclass = ErrorClass.LeftSideBadFormat;
innerres = false;
break;
}
else if (!rightside.InvariantParse(out fnum))
{
errlist += "Number not in correct format on right side" + Environment.NewLine;
errclass = ErrorClass.RightSideBadFormat;
innerres = false;
break;
}
else
{
if (f.matchtype == ConditionEntry.MatchType.NumericEquals)
{
matched = Math.Abs(num - fnum) < 0.0000000001; // allow for rounding
}
else if (f.matchtype == ConditionEntry.MatchType.NumericNotEquals)
{
matched = Math.Abs(num - fnum) >= 0.0000000001;
}
else if (f.matchtype == ConditionEntry.MatchType.NumericGreater)
{
matched = num > fnum;
}
else if (f.matchtype == ConditionEntry.MatchType.NumericGreaterEqual)
{
matched = num >= fnum;
}
else if (f.matchtype == ConditionEntry.MatchType.NumericLessThan)
{
matched = num < fnum;
}
else if (f.matchtype == ConditionEntry.MatchType.NumericLessThanEqual)
{
matched = num <= fnum;
}
else
{
System.Diagnostics.Debug.Assert(false);
}
}
}
}
}
// System.Diagnostics.Debug.WriteLine(fe.eventname + ":Compare " + f.matchtype + " '" + f.contentmatch + "' with '" + vr.value + "' res " + matched + " IC " + fe.innercondition);
if (fe.innercondition == ConditionEntry.LogicalCondition.And) // Short cut, if AND, all must pass, and it did not
{
if (!matched)
{
innerres = false;
break;
}
}
else if (fe.innercondition == ConditionEntry.LogicalCondition.Nand) // Short cut, if NAND, and not matched
{
if (!matched)
{
innerres = true; // positive non match - NAND produces a true
break;
}
}
else if (fe.innercondition == ConditionEntry.LogicalCondition.Or) // Short cut, if OR, and matched
{
if (matched)
{
innerres = true;
break;
}
}
else
{ // short cut, if NOR, and matched, its false
if (matched)
{
innerres = false;
break;
}
}
}
if (!innerres.HasValue) // All tests executed, without a short cut, we set it to a definitive state
{
if (fe.innercondition == ConditionEntry.LogicalCondition.And) // none did not match, producing a false, so therefore AND is true
{
innerres = true;
}
else if (fe.innercondition == ConditionEntry.LogicalCondition.Or) // none did match, producing a true, so therefore OR must be false
{
innerres = false;
}
else if (fe.innercondition == ConditionEntry.LogicalCondition.Nor) // none did match, producing a false, so therefore NOR must be true
{
innerres = true;
}
else // NAND none did match, producing a true, so therefore NAND must be false
{
innerres = false;
}
}
if (innerres.Value && passed != null) // if want a list of passes, do it
{
passed.Add(fe);
}
if (!outerres.HasValue) // if first time, its just the value
{
outerres = innerres.Value;
}
else if (fe.outercondition == ConditionEntry.LogicalCondition.Or)
{
outerres |= innerres.Value;
}
else if (fe.outercondition == ConditionEntry.LogicalCondition.And)
{
outerres &= innerres.Value;
}
else if (fe.outercondition == ConditionEntry.LogicalCondition.Nor)
{
outerres = !(outerres | innerres.Value);
}
else if (fe.outercondition == ConditionEntry.LogicalCondition.Nand)
{
outerres = !(outerres & innerres.Value);
}
}
return(outerres);
}
// static
// Check condition list fel, using the outercondition on each to combine the results
// values are the set of values to use for variable lookups
// pass back errlist, errclass
// optionally pass back conditions which passed
// optional use the function/macro expander on both sides
// optionally shortcircuit on outer AND condition
// obeys disabled
static public bool?CheckConditions(List <Condition> fel, Variables values, out string errlist, out ErrorClass errclass,
List <Condition> passed = null,
Functions functionmacroexpander = null,
bool shortcircuitouter = false,
bool debugit = false)
{
errlist = null;
errclass = ErrorClass.None;
bool?outerres = null;
for (int oc = 0; oc < fel.Count; oc++)
{
Condition cond = fel[oc];
if (cond.Disabled) // disabled means that its ignored
{
continue;
}
bool?innerres = null;
foreach (ConditionEntry ce in cond.Fields)
{
bool matched = false;
if (debugit)
{
System.Diagnostics.Debug.WriteLine($"CE `{ce.ItemName}` {ce.MatchCondition} `{ce.MatchString}`");
}
// these require no left or right
if (ce.MatchCondition == ConditionEntry.MatchType.AlwaysTrue || ce.MatchCondition == ConditionEntry.MatchType.AlwaysFalse)
{
if (ce.ItemName.Length == 0 || ce.ItemName.Equals("Condition", StringComparison.InvariantCultureIgnoreCase)) // empty (legacy) or Condition
{
if (ce.MatchCondition == ConditionEntry.MatchType.AlwaysTrue)
{
matched = true; // matched, else if false, leave as false.
}
}
else
{
errlist += "AlwaysFalse/True does not have on the left side the word 'Condition'" + Environment.NewLine;
errclass = ErrorClass.ExprFormatError;
innerres = false;
break;
}
}
else
{ // at least a left side
string leftside = null;
Functions.ExpandResult leftexpansionresult = Functions.ExpandResult.NoExpansion;
if (functionmacroexpander != null) // if we have a string expander, try the left side
{
leftexpansionresult = functionmacroexpander.ExpandString(ce.ItemName, out leftside);
if (leftexpansionresult == Functions.ExpandResult.Failed) // stop on error
{
errlist += leftside; // add on errors..
innerres = false; // stop loop, false
break;
}
}
// variable names
if (ce.MatchCondition == ConditionEntry.MatchType.IsPresent)
{
if (leftside == null || leftexpansionresult == Functions.ExpandResult.NoExpansion) // no expansion, must be a variable name
{
leftside = values.Qualify(ce.ItemName); // its a straight variable name, allow any special formatting
}
if (values.Exists(leftside) && values[leftside] != null)
{
matched = true;
}
}
else if (ce.MatchCondition == ConditionEntry.MatchType.IsNotPresent)
{
if (leftside == null || leftexpansionresult == Functions.ExpandResult.NoExpansion) // no expansion, must be a variable name
{
leftside = values.Qualify(ce.ItemName); // its a straight variable name, allow any special formatting
}
if (!values.Exists(leftside) || values[leftside] == null)
{
matched = true;
}
}
else
{
// if no expansion, then pass thru the eval engine now or its a variable name
if (leftexpansionresult == Functions.ExpandResult.NoExpansion)
{
string qualname = values.Qualify(ce.ItemName);
leftside = values.Exists(qualname) ? values[qualname] : null; // then lookup.. lookup may also be null if its a pre-def
if (leftside == null)
{
errlist += "Variable '" + qualname + "' does not exist" + Environment.NewLine;
errclass = ErrorClass.LeftSideVarUndefined;
innerres = false;
break; // stop the loop, its a false
}
}
// System.Diagnostics.Debug.WriteLine($".. left side {leftside}");
// left side only
if (ce.MatchCondition == ConditionEntry.MatchType.IsEmpty)
{
matched = leftside.Length == 0;
}
else if (ce.MatchCondition == ConditionEntry.MatchType.IsNotEmpty)
{
matched = leftside.Length > 0;
}
else if (ce.MatchCondition == ConditionEntry.MatchType.IsTrue || ce.MatchCondition == ConditionEntry.MatchType.IsFalse)
{
int inum = 0;
if (leftside.InvariantParse(out inum))
{
matched = (ce.MatchCondition == ConditionEntry.MatchType.IsTrue) ? (inum != 0) : (inum == 0);
}
else
{
errlist += "True/False value is not an integer on left side" + Environment.NewLine;
errclass = ErrorClass.LeftSideBadFormat;
innerres = false;
break;
}
}
else
{
// require a right side
string rightside = null;
Functions.ExpandResult rightexpansionresult = Functions.ExpandResult.NoExpansion;
if (functionmacroexpander != null) // if we have a string expander, pass it thru
{
rightexpansionresult = functionmacroexpander.ExpandString(ce.MatchString, out rightside);
if (rightexpansionresult == Functions.ExpandResult.Failed) // if error, abort
{
errlist += rightside; // add on errors..
innerres = false; // stop loop, false
break;
}
}
else
{
rightside = ce.MatchString; // no eval, we just use the string
}
if (debugit)
{
System.Diagnostics.Debug.WriteLine($"Condition `{leftside}` {ce.MatchCondition} `{rightside}`");
}
if (ce.MatchCondition == ConditionEntry.MatchType.DateBefore || ce.MatchCondition == ConditionEntry.MatchType.DateAfter)
{
DateTime tmevalue, tmecontent;
if (!DateTime.TryParse(leftside, System.Globalization.CultureInfo.CreateSpecificCulture("en-US"), System.Globalization.DateTimeStyles.None, out tmevalue))
{
errlist += "Date time not in correct format on left side: " + leftside + Environment.NewLine;
errclass = ErrorClass.LeftSideBadFormat;
innerres = false;
break;
}
else if (!DateTime.TryParse(rightside, System.Globalization.CultureInfo.CreateSpecificCulture("en-US"), System.Globalization.DateTimeStyles.None, out tmecontent))
{
errlist += "Date time not in correct format on right side: " + rightside + Environment.NewLine;
errclass = ErrorClass.RightSideBadFormat;
innerres = false;
break;
}
else
{
if (ce.MatchCondition == ConditionEntry.MatchType.DateBefore)
{
matched = tmevalue.CompareTo(tmecontent) < 0;
}
else
{
matched = tmevalue.CompareTo(tmecontent) >= 0;
}
}
}
else if (ce.MatchCondition == ConditionEntry.MatchType.Equals)
{
matched = leftside.Equals(rightside, StringComparison.InvariantCultureIgnoreCase);
}
else if (ce.MatchCondition == ConditionEntry.MatchType.EqualsCaseSensitive)
{
matched = leftside.Equals(rightside);
}
else if (ce.MatchCondition == ConditionEntry.MatchType.NotEqual)
{
matched = !leftside.Equals(rightside, StringComparison.InvariantCultureIgnoreCase);
}
else if (ce.MatchCondition == ConditionEntry.MatchType.NotEqualCaseSensitive)
{
matched = !leftside.Equals(rightside);
}
else if (ce.MatchCondition == ConditionEntry.MatchType.Contains)
{
matched = leftside.IndexOf(rightside, StringComparison.InvariantCultureIgnoreCase) >= 0;
}
else if (ce.MatchCondition == ConditionEntry.MatchType.ContainsCaseSensitive)
{
matched = leftside.Contains(rightside);
}
else if (ce.MatchCondition == ConditionEntry.MatchType.DoesNotContain)
{
matched = leftside.IndexOf(rightside, StringComparison.InvariantCultureIgnoreCase) < 0;
}
else if (ce.MatchCondition == ConditionEntry.MatchType.DoesNotContainCaseSensitive)
{
matched = !leftside.Contains(rightside);
}
else if (ce.MatchCondition == ConditionEntry.MatchType.IsOneOf)
{
StringParser p = new StringParser(rightside);
List <string> ret = p.NextQuotedWordList();
if (ret == null)
{
errlist += "IsOneOf value list is not in a optionally quoted comma separated form" + Environment.NewLine;
errclass = ErrorClass.RightSideBadFormat;
innerres = false;
break; // stop the loop, its a false
}
else
{
matched = ret.Contains(leftside, StringComparer.InvariantCultureIgnoreCase);
}
}
else if (ce.MatchCondition == ConditionEntry.MatchType.MatchSemicolon)
{
string[] list = rightside.Split(';').Select(x => x.Trim()).ToArray(); // split and trim
matched = list.Contains(leftside.Trim(), StringComparer.InvariantCultureIgnoreCase); // compare, trimmed, case insensitive
}
else if (ce.MatchCondition == ConditionEntry.MatchType.MatchCommaList)
{
StringCombinations sc = new StringCombinations(',');
sc.ParseString(rightside); // parse, give all combinations
matched = sc.Permutations.Contains(leftside.Trim(), StringComparer.InvariantCultureIgnoreCase); // compare, trimmed, case insensitive
}
else if (ce.MatchCondition == ConditionEntry.MatchType.MatchSemicolonList)
{
StringCombinations sc = new StringCombinations(';');
sc.ParseString(rightside); // parse, give all combinations
matched = sc.Permutations.Contains(leftside.Trim(), StringComparer.InvariantCultureIgnoreCase); // compare, trimmed, case insensitive
}
else if (ce.MatchCondition == ConditionEntry.MatchType.AnyOfAny)
{
StringParser l = new StringParser(leftside);
List <string> ll = l.NextQuotedWordList();
StringParser r = new StringParser(rightside);
List <string> rl = r.NextQuotedWordList();
if (ll == null || rl == null)
{
errlist += "AnyOfAny value list is not in a optionally quoted comma separated form on both sides" + Environment.NewLine;
errclass = ErrorClass.RightSideBadFormat;
innerres = false;
break; // stop the loop, its a false
}
else
{
foreach (string s in ll) // for all left strings
{
if (rl.Contains(s, StringComparer.InvariantCultureIgnoreCase)) // if right has it..
{
matched = true; // matched and break
break;
}
}
}
}
else
{
double fnum = 0, num = 0;
if (!leftside.InvariantParse(out num))
{
errlist += "Number not in correct format on left side: " + leftside + Environment.NewLine;
errclass = ErrorClass.LeftSideBadFormat;
innerres = false;
break;
}
else if (!rightside.InvariantParse(out fnum))
{
errlist += "Number not in correct format on right side: " + rightside + Environment.NewLine;
errclass = ErrorClass.RightSideBadFormat;
innerres = false;
break;
}
else
{
if (ce.MatchCondition == ConditionEntry.MatchType.NumericEquals)
{
matched = num.ApproxEquals(fnum);
}
else if (ce.MatchCondition == ConditionEntry.MatchType.NumericNotEquals)
{
matched = !num.ApproxEquals(fnum);
}
else if (ce.MatchCondition == ConditionEntry.MatchType.NumericGreater)
{
matched = num > fnum;
}
else if (ce.MatchCondition == ConditionEntry.MatchType.NumericGreaterEqual)
{
matched = num >= fnum;
}
else if (ce.MatchCondition == ConditionEntry.MatchType.NumericLessThan)
{
matched = num < fnum;
}
else if (ce.MatchCondition == ConditionEntry.MatchType.NumericLessThanEqual)
{
matched = num <= fnum;
}
else
{
System.Diagnostics.Debug.Assert(false);
}
}
}
}
}
}
// System.Diagnostics.Debug.WriteLine(fe.eventname + ":Compare " + f.matchtype + " '" + f.contentmatch + "' with '" + vr.value + "' res " + matched + " IC " + fe.innercondition);
if (cond.InnerCondition == Condition.LogicalCondition.And) // Short cut, if AND, all must pass, and it did not
{
if (!matched)
{
innerres = false;
break;
}
}
else if (cond.InnerCondition == Condition.LogicalCondition.Nand) // Short cut, if NAND, and not matched
{
if (!matched)
{
innerres = true; // positive non match - NAND produces a true
break;
}
}
else if (cond.InnerCondition == Condition.LogicalCondition.Or) // Short cut, if OR, and matched
{
if (matched)
{
innerres = true;
break;
}
}
else
{ // short cut, if NOR, and matched, its false
if (matched)
{
innerres = false;
break;
}
}
} // end of inner condition list look
// System.Diagnostics.Debug.WriteLine($"Condition list {innerres} {errlist}");
if (!innerres.HasValue) // if does not have a value
{
if (cond.InnerCondition == Condition.LogicalCondition.And) // none did not matched producing a false, so therefore AND is true
{
innerres = true;
}
else if (cond.InnerCondition == Condition.LogicalCondition.Or) // none did matched producing a true, so therefore OR must be false
{
innerres = false;
}
else if (cond.InnerCondition == Condition.LogicalCondition.Nor) // none did matched producing a false, so therefore NOR must be true
{
innerres = true;
}
else // NAND none did matched producing a true, so therefore NAND must be false
{
innerres = false;
}
}
else if (innerres == true)
{
passed?.Add(cond);
}
if (!outerres.HasValue) // if first time, its just the value
{
outerres = innerres.Value;
if (shortcircuitouter && oc < fel.Count - 1) // check short circuits on NEXT ONE! if we have a next one..
{
// if NEXT outer condition is an OR, and we are true
// if NEXT outer condition is an AND, and we are false
if ((fel[oc + 1].OuterCondition == Condition.LogicalCondition.Or && outerres == true) ||
(fel[oc + 1].OuterCondition == Condition.LogicalCondition.And && outerres == false))
{
// System.Diagnostics.Debug.WriteLine("Short circuit on {0} cur {1}", fel[oc + 1].OuterCondition, outerres);
break;
}
}
}
else if (cond.OuterCondition == Condition.LogicalCondition.Or)
{
outerres |= innerres.Value;
if (shortcircuitouter && outerres.Value == true) // no point continuing, first one true wins
{
//System.Diagnostics.Debug.WriteLine("Short circuit second on {0} cur {1}", fe.OuterCondition, outerres);
break;
}
}
else if (cond.OuterCondition == Condition.LogicalCondition.And)
{
outerres &= innerres.Value;
if (shortcircuitouter && outerres.Value == false) // no point continuing, first one false wins
{
//System.Diagnostics.Debug.WriteLine("Short circuit second on {0} cur {1}", fe.OuterCondition, outerres);
break;
}
}
else if (cond.OuterCondition == Condition.LogicalCondition.Nor)
{
outerres = !(outerres | innerres.Value);
}
else if (cond.OuterCondition == Condition.LogicalCondition.Nand)
{
outerres = !(outerres & innerres.Value);
}
else
{
System.Diagnostics.Debug.Assert(false, "Bad outer condition");
}
}
return(outerres);
}
public void AddGrammar(string s)
{
System.Diagnostics.Debug.Assert(updatinggrammar == true);
if (!currentgrammar.ContainsKey(s))
{
var grammar = new List <Grammar>();
#if true
BaseUtils.StringCombinations sb = new BaseUtils.StringCombinations();
foreach (List <List <string> > groups in sb.ParseGroup(s)) // for each semicolon group, give me the word combinations
{
GrammarBuilder builder = new GrammarBuilder();
string gname = "";
foreach (List <string> wordlist in groups) // for each vertical word list
{
if (wordlist.Count == 1) // single entry, must be simple, just add
{
gname = gname.AppendPrePad(wordlist[0], " ");
builder.Append(wordlist[0]);
// System.Diagnostics.Debug.Write("Append " + wordlist[0] + ", ");
}
else
{ // conditional list..
List <GrammarBuilder> sub = new List <GrammarBuilder>();
// if we have an optional entry [], then the parser writes an empty entry after the selection
int emptycount = (from x in wordlist where x.Length == 0 select x).Count(); // is there any empty ones indicating optionality
if (emptycount > 0)
{
gname = gname.AppendPrePad("[", " ");
}
gname = gname.AppendPrePad(string.Join("|", wordlist.Where(x => x.Length > 0)), " ");
foreach (string o in wordlist)
{
if (o.Length > 0)
{
sub.Add(new GrammarBuilder());
sub.Last().Append(o, (emptycount > 0) ? 0 : 1, 1); // indicate number of times, either 1:1 or 0,1 if we have an optional entry
// System.Diagnostics.Debug.Write("Choice " + o + (emptycount>0 ? " (opt), " : ", "));
}
}
if (emptycount > 0)
{
gname += "]";
}
Choices c = new Choices(sub.ToArray());
builder.Append(c);
}
}
System.Diagnostics.Debug.WriteLine($"Grammar {s} -> {gname}");
builder.Culture = ct;
Grammar gr = new Grammar(builder);
gr.Name = gname;
grammar.Add(gr);
}
#else
GrammarBuilder builder = new GrammarBuilder();
builder.Append(s);
builder.Culture = ct;
Grammar gr = new Grammar(builder);
gr.Name = s;
grammar.Add(gr);
#endif
updategrammar[s] = grammar;
// System.Diagnostics.Debug.WriteLine($"{AppTicks.MSd} VR Update Grammar new {s}");
}
else
{
updategrammar[s] = null;
//System.Diagnostics.Debug.WriteLine($"{AppTicks.MSd} VR Update Grammar dup of {s}");
}
}
// Check condition list fel, using the outercondition on each to combine the results.
// Use the eval engine to assemble arguments. Keep arguments as original types (long,double,strings)
// values are the set of values to use for variable lookups
// pass back errlist, errclass
// optionally pass back test executed in order
// shortcircuit on outer AND condition
// obeys disabled
static public bool?CheckConditionsEval(List <Condition> fel, Variables values,
List <ConditionEntry> tests = null, List <string> testerrors = null,
bool debugit = false)
{
Eval evl = new Eval(true, true, true, true, true); // check end, allow fp, allow strings, allow members, allow arrays
evl.ReturnFunctionValue = BaseFunctionsForEval.BaseFunctions; // allow functions
evl.ReturnSymbolValue += (str) => // on symbol lookup
{
string qualname = values.Qualify(str);
if (values.Exists(qualname)) // if we have a variable
{
string text = values[qualname];
if (double.TryParse(text, System.Globalization.NumberStyles.Float, System.Globalization.CultureInfo.InvariantCulture, out double d))
{
if (long.TryParse(text, System.Globalization.NumberStyles.Integer, System.Globalization.CultureInfo.InvariantCulture, out long v)) // if its a number, return number
{
return(v);
}
else
{
return(d);
}
}
else
{
return(text); // else its a string
}
}
else
{
return(new StringParser.ConvertError("Unknown symbol " + qualname));
}
};
bool?outerres = null;
for (int oc = 0; oc < fel.Count; oc++)
{
Condition cond = fel[oc];
if (cond.Disabled) // disabled means that its ignored
{
continue;
}
bool?innerres = null;
foreach (ConditionEntry ce in cond.Fields)
{
bool matched = false;
if (debugit)
{
System.Diagnostics.Debug.WriteLine($"CE `{ce.ItemName}` {ce.MatchCondition} `{ce.MatchString}`");
}
tests?.Add(ce);
testerrors?.Add(null);
// these require no left or right
if (ce.MatchCondition == ConditionEntry.MatchType.AlwaysTrue || ce.MatchCondition == ConditionEntry.MatchType.AlwaysFalse)
{
if (ce.ItemName.Length == 0 || ce.ItemName.Equals("Condition", StringComparison.InvariantCultureIgnoreCase)) // empty (legacy) or Condition
{
if (ce.MatchCondition == ConditionEntry.MatchType.AlwaysTrue)
{
matched = true; // matched, else if false, leave as false.
}
}
else
{
testerrors[testerrors.Count - 1] = "AlwaysFalse/True does not have on the left side the word 'Condition'";
innerres = false;
break;
}
}
else
{
// variable names
if (ce.MatchCondition == ConditionEntry.MatchType.IsPresent)
{
string name = values.Qualify(ce.ItemName); // its a straight variable name, allow any special formatting
if (values.Exists(name) && values[name] != null)
{
matched = true;
}
}
else if (ce.MatchCondition == ConditionEntry.MatchType.IsNotPresent)
{
string name = values.Qualify(ce.ItemName); // its a straight variable name, allow any special formatting
if (!values.Exists(name) || values[name] == null)
{
matched = true;
}
}
else
{
Object leftside;
if (values.Contains(ce.ItemName))
{
string text = values[ce.ItemName];
if (double.TryParse(text, System.Globalization.NumberStyles.Float, System.Globalization.CultureInfo.InvariantCulture, out double d)) // if a double..
{
if (long.TryParse(text, System.Globalization.NumberStyles.Float, System.Globalization.CultureInfo.InvariantCulture, out long v)) // if its a number, return number
{
leftside = v;
}
else
{
leftside = d;
}
}
else
{
leftside = text; // else its a string
}
}
else
{
leftside = evl.EvaluateQuickCheck(ce.ItemName); // evaluate left side
if (evl.InError)
{
if (debugit)
{
System.Diagnostics.Debug.WriteLine($" .. Left side in error ${((StringParser.ConvertError)leftside).ErrorValue}");
}
testerrors[testerrors.Count - 1] = "Left side did not evaluate: " + ce.ItemName;
leftside = null; // indicate condition has failed
}
}
string lstring = leftside as string; // used below
var clf = ConditionEntry.Classify(ce.MatchCondition);
bool stringordate = clf == ConditionEntry.Classification.String || clf == ConditionEntry.Classification.Date;
if (leftside != null) // if we have a leftside, check it for stringness
{
if (stringordate)
{
if (lstring == null)
{
if (debugit)
{
System.Diagnostics.Debug.WriteLine(" .. Left side not string");
}
testerrors[testerrors.Count - 1] = "Left side is not a string: " + ce.ItemName;
leftside = null; // indicate condition has failed
}
}
else if (!(leftside is double || leftside is long)) // must be long or double
{
if (debugit)
{
System.Diagnostics.Debug.WriteLine(" .. Left side not number");
}
testerrors[testerrors.Count - 1] = "Left side is not a number: " + ce.ItemName;
leftside = null; // indicate condition has failed
}
}
if (leftside != null) // we have a good left side
{
// System.Diagnostics.Debug.WriteLine($".. left side {leftside}");
if (ce.MatchCondition == ConditionEntry.MatchType.IsEmpty)
{
matched = lstring.Length == 0;
}
else if (ce.MatchCondition == ConditionEntry.MatchType.IsNotEmpty)
{
matched = lstring.Length > 0;
}
else if (ce.MatchCondition == ConditionEntry.MatchType.IsTrue || ce.MatchCondition == ConditionEntry.MatchType.IsFalse)
{
if (leftside is long) // we already checked about that leftside is double or long
{
matched = (ce.MatchCondition == ConditionEntry.MatchType.IsTrue) ? ((long)leftside != 0) : ((long)leftside == 0);
}
else
{
matched = (ce.MatchCondition == ConditionEntry.MatchType.IsTrue) ? ((double)leftside != 0) : ((double)leftside == 0);
}
}
else
{
// require a right side
Object rightside = evl.EvaluateQuickCheck(ce.MatchString);
if (evl.InError)
{
if (stringordate) // if in error, and we are doing string date comparisions, allow bare on right
{
rightside = ce.MatchString;
}
else
{
testerrors[testerrors.Count - 1] = "Right side did not evaluate: " + ce.MatchString;
rightside = null; // indicate bad right side
}
}
string rstring = rightside as string;
if (rightside != null) // if good right side
{
if (stringordate)
{
if (rstring == null) // must have a string
{
testerrors[testerrors.Count - 1] = "Right side is not a string: " + ce.ItemName;
innerres = false;
rightside = null;
}
}
else if (!(rightside is double || rightside is long))
{
testerrors[testerrors.Count - 1] = "Right side is not a number: " + ce.ItemName;
innerres = false;
rightside = null;
}
}
if (debugit)
{
System.Diagnostics.Debug.WriteLine($" .. `{leftside}` {ce.MatchCondition} `{rightside}`");
}
if (rightside != null)
{
if (ce.MatchCondition == ConditionEntry.MatchType.DateBefore || ce.MatchCondition == ConditionEntry.MatchType.DateAfter)
{
DateTime tmevalue, tmecontent;
if (!DateTime.TryParse(lstring, System.Globalization.CultureInfo.CreateSpecificCulture("en-US"), System.Globalization.DateTimeStyles.None, out tmevalue))
{
testerrors[testerrors.Count - 1] = "Date time not in correct format on left side: " + leftside;
innerres = false;
break;
}
else if (!DateTime.TryParse(rstring, System.Globalization.CultureInfo.CreateSpecificCulture("en-US"), System.Globalization.DateTimeStyles.None, out tmecontent))
{
testerrors[testerrors.Count - 1] = "Date time not in correct format on right side: " + rightside;
innerres = false;
break;
}
else
{
if (ce.MatchCondition == ConditionEntry.MatchType.DateBefore)
{
matched = tmevalue.CompareTo(tmecontent) < 0;
}
else
{
matched = tmevalue.CompareTo(tmecontent) >= 0;
}
}
}
else if (ce.MatchCondition == ConditionEntry.MatchType.Equals)
{
matched = lstring.Equals(rstring, StringComparison.InvariantCultureIgnoreCase);
}
else if (ce.MatchCondition == ConditionEntry.MatchType.EqualsCaseSensitive)
{
matched = lstring.Equals(rstring);
}
else if (ce.MatchCondition == ConditionEntry.MatchType.NotEqual)
{
matched = !lstring.Equals(rstring, StringComparison.InvariantCultureIgnoreCase);
}
else if (ce.MatchCondition == ConditionEntry.MatchType.NotEqualCaseSensitive)
{
matched = !lstring.Equals(rstring);
}
else if (ce.MatchCondition == ConditionEntry.MatchType.Contains)
{
matched = lstring.IndexOf(rstring, StringComparison.InvariantCultureIgnoreCase) >= 0;
}
else if (ce.MatchCondition == ConditionEntry.MatchType.ContainsCaseSensitive)
{
matched = lstring.Contains(rstring);
}
else if (ce.MatchCondition == ConditionEntry.MatchType.DoesNotContain)
{
matched = lstring.IndexOf(rstring, StringComparison.InvariantCultureIgnoreCase) < 0;
}
else if (ce.MatchCondition == ConditionEntry.MatchType.DoesNotContainCaseSensitive)
{
matched = !lstring.Contains(rstring);
}
else if (ce.MatchCondition == ConditionEntry.MatchType.IsOneOf)
{
StringParser p = new StringParser(rstring);
List <string> ret = p.NextQuotedWordList();
if (ret == null)
{
testerrors[testerrors.Count - 1] = "IsOneOf value list is not in a optionally quoted comma separated form";
innerres = false;
break; // stop the loop, its a false
}
else
{
matched = ret.Contains(lstring, StringComparer.InvariantCultureIgnoreCase);
}
}
else if (ce.MatchCondition == ConditionEntry.MatchType.MatchSemicolon)
{
string[] list = rstring.Split(';').Select(x => x.Trim()).ToArray(); // split and trim
matched = list.Contains(lstring.Trim(), StringComparer.InvariantCultureIgnoreCase); // compare, trimmed, case insensitive
}
else if (ce.MatchCondition == ConditionEntry.MatchType.MatchCommaList)
{
StringCombinations sc = new StringCombinations(',');
sc.ParseString(rstring); // parse, give all combinations
matched = sc.Permutations.Contains(lstring.Trim(), StringComparer.InvariantCultureIgnoreCase); // compare, trimmed, case insensitive
}
else if (ce.MatchCondition == ConditionEntry.MatchType.MatchSemicolonList)
{
StringCombinations sc = new StringCombinations(';');
sc.ParseString(rstring); // parse, give all combinations
matched = sc.Permutations.Contains(lstring.Trim(), StringComparer.InvariantCultureIgnoreCase); // compare, trimmed, case insensitive
}
else if (ce.MatchCondition == ConditionEntry.MatchType.AnyOfAny)
{
StringParser l = new StringParser(lstring);
List <string> ll = l.NextQuotedWordList();
StringParser r = new StringParser(rstring);
List <string> rl = r.NextQuotedWordList();
if (ll == null || rl == null)
{
testerrors[testerrors.Count - 1] = "AnyOfAny value list is not in a optionally quoted comma separated form on both sides";
innerres = false;
break; // stop the loop, its a false
}
else
{
foreach (string s in ll) // for all left strings
{
if (rl.Contains(s, StringComparer.InvariantCultureIgnoreCase)) // if right has it..
{
matched = true; // matched and break
break;
}
}
}
}
else
{
if (leftside is double || rightside is double)
{
double lnum = leftside is long?(double)(long)leftside : (double)leftside;
double rnum = rightside is long?(double)(long)rightside : (double)rightside;
if (ce.MatchCondition == ConditionEntry.MatchType.NumericEquals)
{
matched = lnum.ApproxEquals(rnum);
}
else if (ce.MatchCondition == ConditionEntry.MatchType.NumericNotEquals)
{
matched = !lnum.ApproxEquals(rnum);
}
else if (ce.MatchCondition == ConditionEntry.MatchType.NumericGreater)
{
matched = lnum > rnum;
}
else if (ce.MatchCondition == ConditionEntry.MatchType.NumericGreaterEqual)
{
matched = lnum >= rnum;
}
else if (ce.MatchCondition == ConditionEntry.MatchType.NumericLessThan)
{
matched = lnum < rnum;
}
else if (ce.MatchCondition == ConditionEntry.MatchType.NumericLessThanEqual)
{
matched = lnum <= rnum;
}
}
else
{
long lnum = (long)leftside;
long rnum = (long)rightside;
if (ce.MatchCondition == ConditionEntry.MatchType.NumericEquals)
{
matched = lnum == rnum;
}
else if (ce.MatchCondition == ConditionEntry.MatchType.NumericNotEquals)
{
matched = lnum != rnum;
}
else if (ce.MatchCondition == ConditionEntry.MatchType.NumericGreater)
{
matched = lnum > rnum;
}
else if (ce.MatchCondition == ConditionEntry.MatchType.NumericGreaterEqual)
{
matched = lnum >= rnum;
}
else if (ce.MatchCondition == ConditionEntry.MatchType.NumericLessThan)
{
matched = lnum < rnum;
}
else if (ce.MatchCondition == ConditionEntry.MatchType.NumericLessThanEqual)
{
matched = lnum <= rnum;
}
}
}
}
}
}
}
}
if (debugit)
{
System.Diagnostics.Debug.WriteLine($" .. match result {matched}");
}
// System.Diagnostics.Debug.WriteLine(fe.eventname + ":Compare " + f.matchtype + " '" + f.contentmatch + "' with '" + vr.value + "' res " + matched + " IC " + fe.innercondition);
if (cond.InnerCondition == Condition.LogicalCondition.And) // Short cut, if AND, all must pass, and it did not
{
if (!matched)
{
innerres = false;
break;
}
}
else if (cond.InnerCondition == Condition.LogicalCondition.Nand) // Short cut, if NAND, and not matched
{
if (!matched)
{
innerres = true; // positive non match - NAND produces a true
break;
}
}
else if (cond.InnerCondition == Condition.LogicalCondition.Or) // Short cut, if OR, and matched
{
if (matched)
{
innerres = true;
break;
}
}
else
{ // short cut, if NOR, and matched, its false
if (matched)
{
innerres = false;
break;
}
}
} // end of inner condition list look
// System.Diagnostics.Debug.WriteLine($"Condition list {innerres} {errlist}");
if (!innerres.HasValue) // if does not have a value
{
if (cond.InnerCondition == Condition.LogicalCondition.And) // none did not matched producing a false, so therefore AND is true
{
innerres = true;
}
else if (cond.InnerCondition == Condition.LogicalCondition.Or) // none did matched producing a true, so therefore OR must be false
{
innerres = false;
}
else if (cond.InnerCondition == Condition.LogicalCondition.Nor) // none did matched producing a false, so therefore NOR must be true
{
innerres = true;
}
else // NAND none did matched producing a true, so therefore NAND must be false
{
innerres = false;
}
}
if (!outerres.HasValue) // if first time, its just the value
{
outerres = innerres.Value;
if (oc < fel.Count - 1) // check short circuits on NEXT ONE! if we have a next one..
{
// if NEXT outer condition is an OR, and we are true
// if NEXT outer condition is an AND, and we are false
if ((fel[oc + 1].OuterCondition == Condition.LogicalCondition.Or && outerres == true) ||
(fel[oc + 1].OuterCondition == Condition.LogicalCondition.And && outerres == false))
{
// System.Diagnostics.Debug.WriteLine("Short circuit on {0} cur {1}", fel[oc + 1].OuterCondition, outerres);
break;
}
}
}
else if (cond.OuterCondition == Condition.LogicalCondition.Or)
{
outerres |= innerres.Value;
if (outerres.Value == true) // no point continuing, first one true wins
{
//System.Diagnostics.Debug.WriteLine("Short circuit second on {0} cur {1}", fe.OuterCondition, outerres);
break;
}
}
else if (cond.OuterCondition == Condition.LogicalCondition.And)
{
outerres &= innerres.Value;
if (outerres.Value == false) // no point continuing, first one false wins
{
//System.Diagnostics.Debug.WriteLine("Short circuit second on {0} cur {1}", fe.OuterCondition, outerres);
break;
}
}
else if (cond.OuterCondition == Condition.LogicalCondition.Nor)
{
outerres = !(outerres | innerres.Value);
}
else if (cond.OuterCondition == Condition.LogicalCondition.Nand)
{
outerres = !(outerres & innerres.Value);
}
else
{
System.Diagnostics.Debug.Assert(false, "Bad outer condition");
}
}
return(outerres);
}