// EmptyLogicException, DifferentSyntaxesUsedException, UnexpectedSymbolException, InvalidVariableNameException, UnclosedBracketException
private static LogicExpression SplitWordsByOperator(String[] paramArrayOfString, int paramInt1, Operator paramInt2,
ParserSyntax paramParserSyntax)
{
if (paramInt1 == 0)
throw new UnexpectedSymbolException("Operator at beginning of list of arguments");
if (paramInt1 == paramArrayOfString.Length - 1)
{
throw new UnexpectedSymbolException("Operator at end of list of arguments");
}
int m;
if ((paramInt2 == Operator.OperatorXor) || (paramInt2 == Operator.OperatorImplies) || (paramInt2 == Operator.OperatorBiimplies))
{
var arrayOfLogicExpression1 = new LogicExpression[2];
var arrayOfString1 = new String[paramInt1];
var arrayOfString2 = new String[paramArrayOfString.Length - paramInt1 - 1];
for (var mm = 0; mm < arrayOfString1.Length; mm++)
{
arrayOfString1[mm] = paramArrayOfString[mm];
}
m = paramInt1 + 1;
for (int n = 0; n < arrayOfString2.Length; n++)
{
arrayOfString2[n] = paramArrayOfString[(m++)];
}
arrayOfLogicExpression1[0] = ParseWords(arrayOfString1, paramParserSyntax);
arrayOfLogicExpression1[1] = ParseWords(arrayOfString2, paramParserSyntax);
var localLogicBranch1 = new OperatorExpression(paramInt2)
{
Branches = arrayOfLogicExpression1
};
return localLogicBranch1;
}
int i = 2;
for (int k = paramInt1 - 1; k >= 0; k--)
{
var j = GetOperatorValue(paramArrayOfString[k]);
if (j == Operator.NonOperator)
continue;
if (j != paramInt2)
{
break;
}
paramParserSyntax.UpdateLogicSyntax(GetLogicSyntax(paramArrayOfString[k]));
i++;
}
var arrayOfLogicExpression2 = new LogicExpression[i];
m = paramArrayOfString.Length - 1;
for (int i2 = arrayOfLogicExpression2.Length - 1; i2 >= 0; i2--)
{
int i1 = 0;
int i3;
for (i3 = m; i3 >= 0; i3--)
{
var j = GetOperatorValue(paramArrayOfString[i3]);
if (j != paramInt2)
i1++;
else if (j == paramInt2)
{
break;
}
}
var arrayOfString3 = new String[i1];
i3 = m - i1;
int i4 = i1 - 1;
for (int i5 = m; i5 > i3; i5--)
{
arrayOfString3[(i4--)] = paramArrayOfString[i5];
}
m = m - i1 - 1;
arrayOfLogicExpression2[i2] = ParseWords(arrayOfString3, paramParserSyntax);
}
var localLogicBranch2 = new OperatorExpression(paramInt2)
{
Branches = arrayOfLogicExpression2
};
return localLogicBranch2;
}
private static LogicExpression Parse(String paramString, ParserSyntax paramParserSyntax)
{
if (paramString.Length == 0)
{
throw new EmptyLogicException("No expression entered");
}
paramString = StripDown(paramString);
if (paramString.Length == 0)
{
throw new EmptyLogicException("Only whitespace or brackets entered");
}
String[] arrayOfString = BreakDownInToWords(paramString);
return ParseWords(arrayOfString, paramParserSyntax);
}
private static LogicExpression ParseWords(String[] paramArrayOfString, ParserSyntax paramParserSyntax)
{
if (paramArrayOfString.Length == 1)
{
String[] arrayOfString = BreakDownInToWords(paramArrayOfString[0]);
if (arrayOfString.Length == 1)
{
return paramParserSyntax.GenerateLiteral(paramArrayOfString[0]);
}
paramArrayOfString = arrayOfString;
}
for (int j = paramArrayOfString.Length - 1; j >= 0; j--)
{
var i = GetOperatorValue(paramArrayOfString[j]);
LogicSyntax k;
switch (i)
{
case (Operator.OperatorImplies):
k = GetLogicSyntax(paramArrayOfString[j]);
if (k != 0)
{
paramParserSyntax.UpdateLogicSyntax(k);
}
return SplitWordsByOperator(paramArrayOfString, j, Operator.OperatorImplies, paramParserSyntax);
case Operator.OperatorBiimplies:
k = GetLogicSyntax(paramArrayOfString[j]);
if (k != 0)
{
paramParserSyntax.UpdateLogicSyntax(k);
}
return SplitWordsByOperator(paramArrayOfString, j, Operator.OperatorBiimplies, paramParserSyntax);
}
}
{
for (int j = paramArrayOfString.Length - 1; j >= 0; j--)
{
var i = GetOperatorValue(paramArrayOfString[j]);
if (i == Operator.Or)
{
paramParserSyntax.UpdateLogicSyntax(GetLogicSyntax(paramArrayOfString[j]));
return SplitWordsByOperator(paramArrayOfString, j, Operator.Or, paramParserSyntax);
}
if (paramArrayOfString[j].Equals("!="))
{
return SplitWordsByOperator(paramArrayOfString, j, Operator.OperatorXor, paramParserSyntax);
}
}
}
for (int j = paramArrayOfString.Length - 1; j >= 0; j--)
{
if (GetOperatorValue(paramArrayOfString[j]) != 0)
continue;
paramParserSyntax.UpdateLogicSyntax(GetLogicSyntax(paramArrayOfString[j]));
return SplitWordsByOperator(paramArrayOfString, j, 0, paramParserSyntax);
}
if (paramParserSyntax.NegationSyntax == NegationSyntax.Unknown)
{
if (paramArrayOfString[0].Equals("NOT", StringComparison.InvariantCultureIgnoreCase))
paramParserSyntax.UpdateNegationSyntax(NegationSyntax.Written);
else if (paramArrayOfString[0].Equals("~"))
paramParserSyntax.UpdateNegationSyntax(NegationSyntax.Before);
else if (paramArrayOfString[(paramArrayOfString.Length - 1)].Equals("'"))
{
paramParserSyntax.UpdateNegationSyntax(NegationSyntax.After);
}
}
bool negated = false;
var kk = paramArrayOfString.Length - 1;
LogicExpression localLogicExpression = null;
int m;
switch (paramParserSyntax.NegationSyntax)
{
case NegationSyntax.Written:
for (m = 0; m < kk; m++)
{
if (!paramArrayOfString[m].Equals("NOT", StringComparison.InvariantCultureIgnoreCase))
{
throw new UnexpectedSymbolException("Expected 'NOT' instead of (or operator after) '" + paramArrayOfString[m] + "'");
}
negated = negated == false;
}
localLogicExpression = Parse(paramArrayOfString[kk], paramParserSyntax);
break;
case NegationSyntax.Before:
for (m = 0; m < kk; m++)
{
if (!paramArrayOfString[m].Equals("~", StringComparison.InvariantCultureIgnoreCase))
{
throw new UnexpectedSymbolException("Expected '~' instead of (or operator after) '" + paramArrayOfString[m] + "'");
}
negated = negated == false;
}
localLogicExpression = Parse(paramArrayOfString[kk], paramParserSyntax);
break;
case NegationSyntax.After:
for (m = kk; m > 0; m--)
{
if (!paramArrayOfString[m].Equals("'", StringComparison.InvariantCultureIgnoreCase))
{
throw new UnexpectedSymbolException("Expected \"'\" instead of (or operator before) '" + paramArrayOfString[m] +
"'");
}
negated = !negated;
}
localLogicExpression = Parse(paramArrayOfString[0], paramParserSyntax);
break;
}
localLogicExpression.Negated = negated;
return localLogicExpression;
}
// EmptyLogicException, DifferentSyntaxesUsedException, UnexpectedSymbolException, InvalidVariableNameException, UnclosedBracketException
public static ParsedExpression ParseLogic(string paramString)
{
var localParserSyntax = new ParserSyntax();
LogicExpression localLogicExpression = Parse(paramString, localParserSyntax);
LogicSyntax i = localParserSyntax.LogicSyntax;
NegationSyntax j = localParserSyntax.NegationSyntax;
if (i == LogicSyntax.Unknown)
{
if (j == NegationSyntax.Unknown)
{
i = LogicSyntax.LogicSyntaxDotPlus;
j = GetNegationSyntax(i);
}
else
{
switch (j)
{
case NegationSyntax.Written:
i = LogicSyntax.Written;
break;
case NegationSyntax.Before:
i = LogicSyntax.LogicSyntaxDotPlus;
break;
case NegationSyntax.After:
i = LogicSyntax.LogicSyntaxDotPlus;
break;
}
}
}
return new ParsedExpression(paramString, localLogicExpression, i, j);
}