public static INumerable BuildNumericTernary(List <Token> tokens)
{
IBoolable condition = BoolableBuilder.Build(GetTernaryCondition(tokens));
if (condition.IsNull())
{
return(null);
}
INumerable confirmationCase = NumerableBuilder.Build(GetTernaryConfirmation(tokens));
if (confirmationCase.IsNull())
{
return(null);
}
INumerable negationCase = NumerableBuilder.Build(GetTernaryNegation(tokens));
if (negationCase.IsNull())
{
return(null);
}
return(new NumericTernary(condition, confirmationCase, negationCase));
}
public static ISubcommand BuildWhere(List <Token> tokens)
{
IBoolable iboo = BoolableBuilder.Build(tokens);
if (iboo.IsNull())
{
throw new SyntaxErrorException("ERROR! In list declaration there is something wrong with expression: where.");
}
else
{
return(new Where(iboo));
}
}
private static IBoolable BuildExpression(List <Token> tokens)
{
// turn list of tokens into list of BoolExpressionElements
// they are in usual infix notation
// when this is done, their order is changed to Reverse Polish Notation
// meanwhile check, if it all can be represented as simple one negated IBoolable
// finally build BoolExpression
List <IBoolExpressionElement> infixList = new List <IBoolExpressionElement>();
List <Token> currentTokens = new List <Token>();
bool readingFunction = false;
Token previousToken = new Token(TokenType.Null);
// first, merge many tokens into fewer number of IBoolables
foreach (Token tok in tokens)
{
bool actionDone = false;
if (TokenGroups.IsLogicSign(tok.GetTokenType()))
{
if (readingFunction)
{
if (Brackets.AllBracketsClosed(currentTokens))
{
IBoolable ibo = BoolableBuilder.Build(currentTokens);
if (!ibo.IsNull())
{
infixList.Add(ibo);
}
else
{
return(null);
}
currentTokens.Clear();
readingFunction = false;
infixList.Add(new BoolExpressionOperator(GetBEOT(tok.GetTokenType())));
}
else
{
currentTokens.Add(tok);
}
}
else
{
if (currentTokens.Count > 0)
{
IBoolable ibo = BoolableBuilder.Build(currentTokens);
if (!ibo.IsNull())
{
infixList.Add(ibo);
}
else
{
return(null);
}
currentTokens.Clear();
}
infixList.Add(new BoolExpressionOperator(GetBEOT(tok.GetTokenType())));
}
actionDone = true;
}
if (tok.GetTokenType().Equals(TokenType.BracketOn))
{
if (readingFunction)
{
currentTokens.Add(tok);
}
else
{
if (currentTokens.Count == 1 && previousToken.GetTokenType().Equals(TokenType.Variable))
{
currentTokens.Add(tok);
readingFunction = true;
}
else
{
if (currentTokens.Count > 0)
{
IBoolable ibo = BoolableBuilder.Build(currentTokens);
if (!ibo.IsNull())
{
infixList.Add(ibo);
}
else
{
return(null);
}
currentTokens.Clear();
}
infixList.Add(new BoolExpressionOperator(BoolExpressionOperatorType.BracketOn));
}
}
actionDone = true;
}
if (tok.GetTokenType().Equals(TokenType.BracketOff))
{
if (readingFunction)
{
if (Brackets.AllBracketsClosed(currentTokens))
{
IBoolable ibo = BoolableBuilder.Build(currentTokens);
if (!ibo.IsNull())
{
infixList.Add(ibo);
}
else
{
return(null);
}
currentTokens.Clear();
readingFunction = false;
infixList.Add(new BoolExpressionOperator(BoolExpressionOperatorType.BracketOff));
}
else
{
currentTokens.Add(tok);
}
}
else
{
if (currentTokens.Count > 0)
{
IBoolable ibo = BoolableBuilder.Build(currentTokens);
if (!ibo.IsNull())
{
infixList.Add(ibo);
}
else
{
return(null);
}
currentTokens.Clear();
}
infixList.Add(new BoolExpressionOperator(BoolExpressionOperatorType.BracketOff));
}
actionDone = true;
}
if (!actionDone)
{
currentTokens.Add(tok);
}
previousToken = tok;
}
if (currentTokens.Count > 0)
{
IBoolable ibo = BoolableBuilder.Build(currentTokens);
if (!ibo.IsNull())
{
infixList.Add(ibo);
}
else
{
return(null);
}
}
// try to build negation of one boolable
if (infixList.Count == 2 && (infixList[0] is BoolExpressionOperator) && (infixList[1] is IBoolable) &&
(infixList[0] as BoolExpressionOperator).GetOperatorType().Equals(BoolExpressionOperatorType.Not))
{
return(new NegatedBoolable(infixList[1] as IBoolable));
}
// check if value of infixlist can be computed (check order of elements)
if (!CheckExpressionComputability(infixList))
{
throw new SyntaxErrorException("ERROR! Wrong syntax of logic expression.");
}
// if everything is right, finally build BoolExpression in RPN
return(new BoolExpression(ReversePolishNotation(infixList)));
}
public static INumerable Build(List <Token> tokens)
{
// try to build Boolable
IBoolable ibo = BoolableBuilder.Build(tokens);
if (!ibo.IsNull())
{
return(ibo as INumerable);
}
// remove first and last bracket if it is there
while (tokens[0].GetTokenType().Equals(TokenType.BracketOn) && tokens[tokens.Count - 1].GetTokenType().Equals(TokenType.BracketOff) &&
!Brackets.ContainsIndependentBracketsPairs(tokens, BracketsType.Normal))
{
List <Token> tokensCopy = tokens.Select(t => t.Clone()).ToList();
tokensCopy.RemoveAt(tokens.Count - 1);
tokensCopy.RemoveAt(0);
tokens = tokensCopy;
}
// try to build simple one-token Numerable
if (tokens.Count == 1)
{
if (tokens[0].GetTokenType().Equals(TokenType.Variable))
{
string str = tokens[0].GetContent();
if (InterVariables.GetInstance().Contains(str, InterVarType.Number))
{
return(new NumericVariableRefer(str));
}
else
{
// try to build reference to element of time variable
INumerable inum = BuildTimeVariableRefer(tokens[0]);
if (!inum.IsNull())
{
return(inum);
}
}
}
if (tokens[0].GetTokenType().Equals(TokenType.NumericConstant))
{
return(new NumericConstant(tokens[0].GetNumericContent()));
}
}
// try to build numeric ternary
if (TernaryBuilder.IsPossibleTernary(tokens))
{
INumerable inum = TernaryBuilder.BuildNumericTernary(tokens);
if (!inum.IsNull())
{
return(inum);
}
}
// try to build "count" and "count inside"
if (tokens[0].GetTokenType().Equals(TokenType.Count))
{
INumerable inum = BuildCount(tokens);
if (!inum.IsNull())
{
return(inum);
}
}
// try to build numeric function
if (Functions.IsPossibleFunction(tokens))
{
INumerable inu = NumericFunction.Build(tokens);
if (!inu.IsNull())
{
return(inu);
}
}
// try to build expression: many elements with operators +, -, *, /, %
if (TokenGroups.ContainsArithmeticTokensOutsideBrackets(tokens))
{
return(BuildExpression(tokens));
}
else
{
return(null);
}
}
