private static string[] ExpressionToTokens(string expression)
{
List <string> list = new List <string>();
string text = string.Empty;
for (int i = 0; i < expression.Length; i++)
{
char c = expression[i];
if (ExpressionEvaluator.IsCommand(c))
{
if (text.Length > 0)
{
list.Add(text);
}
list.Add(c.ToString());
text = string.Empty;
}
else if (c != ' ')
{
text += c;
}
}
if (text.Length > 0)
{
list.Add(text);
}
return(list.ToArray());
}
private static string[] ExpressionToTokens(string expression)
{
List <string> stringList = new List <string>();
string empty = string.Empty;
for (int index = 0; index < expression.Length; ++index)
{
char character = expression[index];
if (ExpressionEvaluator.IsCommand(character))
{
if (empty.Length > 0)
{
stringList.Add(empty);
}
stringList.Add(character.ToString());
empty = string.Empty;
}
else if ((int)character != 32)
{
empty += (string)(object)character;
}
}
if (empty.Length > 0)
{
stringList.Add(empty);
}
return(stringList.ToArray());
}
private static string[] FixUnaryOperators(string[] tokens)
{
string[] result;
if (tokens.Length == 0)
{
result = tokens;
}
else
{
if (tokens[0] == "-")
{
tokens[0] = "u";
}
for (int i = 1; i < tokens.Length - 1; i++)
{
string a = tokens[i];
string token = tokens[i - 1];
string a2 = tokens[i - 1];
if (a == "-" && (ExpressionEvaluator.IsCommand(token) || a2 == "(" || a2 == ")"))
{
tokens[i] = "u";
}
}
result = tokens;
}
return(result);
}
private static bool IsCommand(string token)
{
if (token.Length != 1)
{
return(false);
}
return(ExpressionEvaluator.IsCommand(token[0]));
}
private static string[] InfixToRPN(string[] tokens)
{
Stack <char> charStack = new Stack <char>();
Stack <string> source = new Stack <string>();
foreach (string token in tokens)
{
if (ExpressionEvaluator.IsCommand(token))
{
char character = token[0];
switch (character)
{
case '(':
charStack.Push(character);
continue;
case ')':
while (charStack.LongCount <char>() > 0L && (int)charStack.Peek() != 40)
{
source.Push(charStack.Pop().ToString());
}
if (charStack.LongCount <char>() > 0L)
{
int num = (int)charStack.Pop();
continue;
}
continue;
default:
ExpressionEvaluator.Operator newOperator = ExpressionEvaluator.CharToOperator(character);
while (ExpressionEvaluator.NeedToPop(charStack, newOperator))
{
source.Push(charStack.Pop().ToString());
}
charStack.Push(character);
continue;
}
}
else
{
source.Push(token);
}
}
while (charStack.LongCount <char>() > 0L)
{
source.Push(charStack.Pop().ToString());
}
return(source.Reverse <string>().ToArray <string>());
}
private static string[] InfixToRPN(string[] tokens)
{
Stack <char> stack = new Stack <char>();
Stack <string> stack2 = new Stack <string>();
for (int i = 0; i < tokens.Length; i++)
{
string text = tokens[i];
if (ExpressionEvaluator.IsCommand(text))
{
char c = text[0];
if (c == '(')
{
stack.Push(c);
}
else if (c == ')')
{
while (stack.LongCount <char>() > 0L && stack.Peek() != '(')
{
stack2.Push(stack.Pop().ToString());
}
if (stack.LongCount <char>() > 0L)
{
stack.Pop();
}
}
else
{
ExpressionEvaluator.Operator newOperator = ExpressionEvaluator.CharToOperator(c);
while (ExpressionEvaluator.NeedToPop(stack, newOperator))
{
stack2.Push(stack.Pop().ToString());
}
stack.Push(c);
}
}
else
{
stack2.Push(text);
}
}
while (stack.LongCount <char>() > 0L)
{
stack2.Push(stack.Pop().ToString());
}
return(stack2.Reverse <string>().ToArray <string>());
}
private static string[] InfixToRPN(string[] tokens)
{
Stack <char> stack = new Stack <char>();
Queue <string> queue = new Queue <string>();
for (int i = 0; i < tokens.Length; i++)
{
string text = tokens[i];
if (ExpressionEvaluator.IsCommand(text))
{
char c = text[0];
if (c == '(')
{
stack.Push(c);
}
else if (c == ')')
{
while (stack.Count > 0 && stack.Peek() != '(')
{
queue.Enqueue(stack.Pop().ToString());
}
if (stack.Count > 0)
{
stack.Pop();
}
}
else
{
ExpressionEvaluator.Operator newOperator = ExpressionEvaluator.CharToOperator(c);
while (ExpressionEvaluator.NeedToPop(stack, newOperator))
{
queue.Enqueue(stack.Pop().ToString());
}
stack.Push(c);
}
}
else
{
queue.Enqueue(text);
}
}
while (stack.Count > 0)
{
queue.Enqueue(stack.Pop().ToString());
}
return(queue.ToArray());
}
private static T Evaluate <T>(string[] tokens)
{
Stack <string> stack = new Stack <string>();
T result;
for (int i = 0; i < tokens.Length; i++)
{
string text = tokens[i];
if (ExpressionEvaluator.IsOperator(text))
{
ExpressionEvaluator.Operator @operator = ExpressionEvaluator.CharToOperator(text[0]);
List <T> list = new List <T>();
bool flag = true;
while (stack.Count > 0 && !ExpressionEvaluator.IsCommand(stack.Peek()) && list.Count < @operator.inputs)
{
T item;
flag &= ExpressionEvaluator.TryParse <T>(stack.Pop(), out item);
list.Add(item);
}
list.Reverse();
if (!flag || list.Count != @operator.inputs)
{
result = default(T);
return(result);
}
Stack <string> arg_CF_0 = stack;
T t = ExpressionEvaluator.Evaluate <T>(list.ToArray(), text[0]);
arg_CF_0.Push(t.ToString());
}
else
{
stack.Push(text);
}
}
if (stack.Count == 1)
{
T t2;
if (ExpressionEvaluator.TryParse <T>(stack.Pop(), out t2))
{
result = t2;
return(result);
}
}
result = default(T);
return(result);
}
private static string[] FixUnaryOperators(string[] tokens)
{
if (tokens.Length == 0)
{
return(tokens);
}
if (tokens[0] == "-")
{
tokens[0] = "u";
}
for (int index = 1; index < tokens.Length - 1; ++index)
{
string token1 = tokens[index];
string token2 = tokens[index - 1];
string token3 = tokens[index - 1];
if (token1 == "-" && (ExpressionEvaluator.IsCommand(token2) || token3 == "(" || token3 == ")"))
{
tokens[index] = "u";
}
}
return(tokens);
}
private static T Evaluate <T>(string[] tokens)
{
Stack <string> source = new Stack <string>();
foreach (string token in tokens)
{
if (ExpressionEvaluator.IsOperator(token))
{
ExpressionEvaluator.Operator @operator = ExpressionEvaluator.CharToOperator(token[0]);
List <T> objList = new List <T>();
bool flag = true;
while (source.LongCount <string>() > 0L && !ExpressionEvaluator.IsCommand(source.Peek()) && objList.Count < @operator.inputs)
{
T result;
flag &= ExpressionEvaluator.TryParse <T>(source.Pop(), out result);
objList.Add(result);
}
objList.Reverse();
if (!flag || objList.Count != @operator.inputs)
{
return(default(T));
}
source.Push(ExpressionEvaluator.Evaluate <T>(objList.ToArray(), token[0]).ToString());
}
else
{
source.Push(token);
}
}
T result1;
if (source.LongCount <string>() == 1L && ExpressionEvaluator.TryParse <T>(source.Pop(), out result1))
{
return(result1);
}
return(default(T));
}
private static bool IsCommand(string token)
{
return(token.Length == 1 && ExpressionEvaluator.IsCommand(token[0]));
}
