private ExpressionNode ParseRelationalExpression()
{
var left = ParseAdditiveExpression();
while (IsOperator('<') || IsOperator('>') || IsOperator('L') || IsOperator('G'))
{
var o = (Operator)Token;
NextToken();
switch (o.Value)
{
case '<':
left = new LessThan(left, ParseAdditiveExpression());
break;
case '>':
left = new GreaterThan(left, ParseAdditiveExpression());
break;
case 'L':
left = new LessEqual(left, ParseAdditiveExpression());
break;
case 'G':
left = new GreaterEqual(left, ParseAdditiveExpression());
break;
}
}
return(left);
}
public void Visit(GreaterEqual n)
{
Helpers.Write("(");
n.LeftExpression.Accept(this);
Helpers.Write(" >= ");
n.RightExpression.Accept(this);
Helpers.Write(")");
}
public override void VisitGreaterEqual(GreaterEqual n)
{
SetupOperands(n);
//check eq
_gen.Emit(OpCodes.Ceq);
SetupOperands(n);
//check gt
_gen.Emit(OpCodes.Cgt);
//or them
_gen.Emit(OpCodes.Or);
_lastWalkedType = typeof(bool);
}
public string Visit(GreaterEqual node)
{
var result = "";
result += "\t\tldc.i4 42\n";
result += Visit((dynamic)node[0]);
result += Visit((dynamic)node[1]);
var labelSuccess = GenerateLabel();
result += "\t\tbge " + labelSuccess + "\n";
result += "\t\tpop\n";
result += "\t\tldc.i4 0\n";
result += "\t\t" + labelSuccess + ":\n";
return(result);
}
public void Visit(GreaterEqual n)
{
Helpers.WriteLine($"{_tab}{n.Text} [{n.Location.StartLine}, {n.Location.StartColumn}]");
Tab();
Helpers.WriteLine($"{_tab}Left");
Tab();
n.LeftExpression.Accept(this);
Untab();
Helpers.WriteLine($"{_tab}Right");
Tab();
n.RightExpression.Accept(this);
Untab();
Untab();
}
public void Visit(GreaterEqual n)
{
Globals.Builder.Start($"greater equal (>=) [{n.Location.StartLine}, {n.Location.StartColumn}]");
WriteBinaryExpression("cmp", n.LeftExpression, n.RightExpression);
var labelFalse = $"greaterEqualFalse{Globals.Builder.Count()}";
var labelEnd = $"greaterEqualEnd{Globals.Builder.Count()}";
Globals.Builder.WriteUnaryOp("jnge", labelFalse);
Globals.Builder.WriteBinaryOp("mov", "rax", 1.ToString());
Globals.Builder.WriteUnaryOp("jmp", labelEnd);
Globals.Builder.WriteLabel(labelFalse);
Globals.Builder.WriteBinaryOp("mov", "rax", 0.ToString());
Globals.Builder.WriteLabel(labelEnd);
Globals.Builder.End($"greater equal (>=) [{n.Location.EndLine}, {n.Location.EndColumn}]");
}
private static Operator GetOperator(char[] sql, int beginIndex, int endIndex)
{
char c;
Operator op1 = null;
Operator op2 = null;
for (int i = beginIndex; i < endIndex;)
{
c = sql[i];
if (c == '+')
{
op2 = new Add(sql, i, i);
i++;
}
else if (c == '-')
{
op2 = new Sub(sql, i, i);
i++;
}
else if (c == '*')
{
op2 = new Multi(sql, i, i);
i++;
}
else if (c == '/')
{
op2 = new Div(sql, i, i);
i++;
}
else if (
(i + 2 <= endIndex)
&&
(c == 'a' && sql[i + 1] == 'n' && sql[i + 2] == 'd')
&&
(i == beginIndex || StrUtil.IsOneOf(sql[i - 1], Parser._whiteSpaces))
&&
(i + 2 == endIndex || i + 3 <= endIndex && StrUtil.IsOneOf(sql[i + 3], Parser._whiteSpaces))
)
{
op2 = new And(sql, i, i + 2);
i = i + 3;
}
else if (
(i + 1 <= endIndex)
&&
(c == 'o' && sql[i + 1] == 'r')
&&
(i == beginIndex || StrUtil.IsOneOf(sql[i - 1], Parser._whiteSpaces))
&&
(i + 1 == endIndex || i + 2 <= endIndex && StrUtil.IsOneOf(sql[i + 2], Parser._whiteSpaces))
)
{
op2 = new Or(sql, i, i + 1);
i = i + 2;
}
else if (
(i + 2 <= endIndex)
&&
(c == 'n' && sql[i + 1] == 'o' && sql[i + 2] == 't')
&&
(i == beginIndex || StrUtil.IsOneOf(sql[i - 1], Parser._whiteSpaces))
&&
(i + 2 == endIndex || i + 3 <= endIndex && StrUtil.IsOneOf(sql[i + 3], Parser._whiteSpaces))
)
{
op2 = new Not(sql, i, i + 2);
i = i + 3;
}
else if (
(i + 1 <= endIndex)
&&
(c == '>' && sql[i + 1] == '=')
)
{
op2 = new GreaterEqual(sql, i, i + 1);
i = i + 2;
}
else if (
(i + 1 <= endIndex)
&&
(c == '<' && sql[i + 1] == '=')
)
{
op2 = new LessEqual(sql, i, i + 1);
i = i + 2;
}
else if (
(i + 1 <= endIndex)
&&
(c == '!' && sql[i + 1] == '=')
)
{
op2 = new NotEqual(sql, i, i + 1);
i = i + 2;
}
else if (c == '=')
{
op2 = new Equal(sql, i, i);
i++;
}
else if (c == '>')
{
op2 = new Greater(sql, i, i);
i++;
}
else if (c == '<')
{
op2 = new Less(sql, i, i);
i++;
}
else
{
i++;
}
if (op1 == null)
{
if (op2 != null)
{
op1 = op2;
}
}
// 对于 Priority（优先级） 相同 的 运算符，取 最左边 的 , 这是 为了 适应 Not(非) 运算符 的 特性
// Not 运算符 是 一元运算符 。 其它 运算符 都是 二元运算符 ， 从左往右 结合 和 从右往左 结合 都一样
// 但 Not 运算符 只能 从左往右 结合， 因为 从右往左 结合 会 找不到 操作数
// 从 编程 的 角度 来 看， 从左往右 的 思路 也 比较 顺
// 但 等价性 上来看， 我们 人类 的 计算习惯 是 从左到右， 而 这个 计算顺序 对应在 计算机 里 是 从右往左 结合运算符
// 计算机 从右往左 结合运算符 之后 执行计算 的 顺序 就是 从左到右
// 而 从左往右 结合运算符 的 执行计算顺序 是 从右到左
// 但 不管 计算顺序 是 从左到右 还是 从右到左， 结果 都一样
// 综上， 从 编程 的 角度 考虑， 我们选择 了 从左到右 结合 运算符， 执行计算 的 顺序 就是 从右到左
else if (op2 != null && op2.Priority < op1.Priority)
{
op1 = op2;
}
//if (c == '+')
// return new Add(sql, i, i);
//else if (c == '-')
// return new Sub(sql, i, i);
//else if (c == '*')
// return new Multi(sql, i, i);
//else if (c == '/')
// return new Div(sql, i, i);
//else if (c == 'a' && sql[i + 1] == 'n' && sql[i + 2] == 'd')
// return new And(sql, i, i + 2);
//else if (c == 'o' && sql[i + 1] == 'r')
// return new Or(sql, i, i + 1);
//else if (c == 'n' && sql[i + 1] == 'o' && sql[i + 1] == 't')
// return new Not(sql, i, i + 2);
//else if (c == '=')
// return new Equal(sql, i, i + 1);
//else if (c == '>')
// return new Greater(sql, i, i);
//else if (c == '<')
// return new Less(sql, i, i);
//else if (c == '>' && sql[i + 1] == '=')
// return new GreaterEqual(sql, i, i + 1);
//else if (c == '<' && sql[i + 1] == '=')
// return new LessEqual(sql, i, i + 1);
//else if (c == '!' && sql[i + 1] == '=')
// return new NotEqual(sql, i, i + 1);
}
return(op1);
//return null;
}
/**
* Parses the sublist of tokens. In most cases this will equate to
* the full list
*
* @param len the length of the subexpression to parse
* @exception FormulaException
*/
private void parseSubExpression(int len)
{
int tokenVal = 0;
Token t = null;
// Indicates that we are parsing the incredibly complicated and
// hacky if construct that MS saw fit to include, the gits
Stack<ParseItem> ifStack = new Stack<ParseItem>();
// The end position of the sub-expression
int endpos = pos + len;
while (pos < endpos)
{
tokenVal = tokenData[pos];
pos++;
t = Token.getToken(tokenVal);
if (t == Token.UNKNOWN)
{
throw new FormulaException
(FormulaException.UNRECOGNIZED_TOKEN,tokenVal);
}
Assert.verify(t != Token.UNKNOWN);
// Operands
if (t == Token.REF)
{
CellReference cr = new CellReference(relativeTo);
pos += cr.read(tokenData,pos);
tokenStack.Push(cr);
}
else if (t == Token.REFERR)
{
CellReferenceError cr = new CellReferenceError();
pos += cr.read(tokenData,pos);
tokenStack.Push(cr);
}
else if (t == Token.ERR)
{
ErrorConstant ec = new ErrorConstant();
pos += ec.read(tokenData,pos);
tokenStack.Push(ec);
}
else if (t == Token.REFV)
{
SharedFormulaCellReference cr =
new SharedFormulaCellReference(relativeTo);
pos += cr.read(tokenData,pos);
tokenStack.Push(cr);
}
else if (t == Token.REF3D)
{
CellReference3d cr = new CellReference3d(relativeTo,workbook);
pos += cr.read(tokenData,pos);
tokenStack.Push(cr);
}
else if (t == Token.AREA)
{
Area a = new Area();
pos += a.read(tokenData,pos);
tokenStack.Push(a);
}
else if (t == Token.AREAV)
{
SharedFormulaArea a = new SharedFormulaArea(relativeTo);
pos += a.read(tokenData,pos);
tokenStack.Push(a);
}
else if (t == Token.AREA3D)
{
Area3d a = new Area3d(workbook);
pos += a.read(tokenData,pos);
tokenStack.Push(a);
}
else if (t == Token.NAME)
{
Name n = new Name();
pos += n.read(tokenData,pos);
n.setParseContext(parseContext);
tokenStack.Push(n);
}
else if (t == Token.NAMED_RANGE)
{
NameRange nr = new NameRange(nameTable);
pos += nr.read(tokenData,pos);
nr.setParseContext(parseContext);
tokenStack.Push(nr);
}
else if (t == Token.INTEGER)
{
IntegerValue i = new IntegerValue();
pos += i.read(tokenData,pos);
tokenStack.Push(i);
}
else if (t == Token.DOUBLE)
{
DoubleValue d = new DoubleValue();
pos += d.read(tokenData,pos);
tokenStack.Push(d);
}
else if (t == Token.BOOL)
{
BooleanValue bv = new BooleanValue();
pos += bv.read(tokenData,pos);
tokenStack.Push(bv);
}
else if (t == Token.STRING)
{
StringValue sv = new StringValue(settings);
pos += sv.read(tokenData,pos);
tokenStack.Push(sv);
}
else if (t == Token.MISSING_ARG)
{
MissingArg ma = new MissingArg();
pos += ma.read(tokenData,pos);
tokenStack.Push(ma);
}
// Unary Operators
else if (t == Token.UNARY_PLUS)
{
UnaryPlus up = new UnaryPlus();
pos += up.read(tokenData,pos);
addOperator(up);
}
else if (t == Token.UNARY_MINUS)
{
UnaryMinus um = new UnaryMinus();
pos += um.read(tokenData,pos);
addOperator(um);
}
else if (t == Token.PERCENT)
{
Percent p = new Percent();
pos += p.read(tokenData,pos);
addOperator(p);
}
// Binary Operators
else if (t == Token.SUBTRACT)
{
Subtract s = new Subtract();
pos += s.read(tokenData,pos);
addOperator(s);
}
else if (t == Token.ADD)
{
Add s = new Add();
pos += s.read(tokenData,pos);
addOperator(s);
}
else if (t == Token.MULTIPLY)
{
Multiply s = new Multiply();
pos += s.read(tokenData,pos);
addOperator(s);
}
else if (t == Token.DIVIDE)
{
Divide s = new Divide();
pos += s.read(tokenData,pos);
addOperator(s);
}
else if (t == Token.CONCAT)
{
Concatenate c = new Concatenate();
pos += c.read(tokenData,pos);
addOperator(c);
}
else if (t == Token.POWER)
{
Power p = new Power();
pos += p.read(tokenData,pos);
addOperator(p);
}
else if (t == Token.LESS_THAN)
{
LessThan lt = new LessThan();
pos += lt.read(tokenData,pos);
addOperator(lt);
}
else if (t == Token.LESS_EQUAL)
{
LessEqual lte = new LessEqual();
pos += lte.read(tokenData,pos);
addOperator(lte);
}
else if (t == Token.GREATER_THAN)
{
GreaterThan gt = new GreaterThan();
pos += gt.read(tokenData,pos);
addOperator(gt);
}
else if (t == Token.GREATER_EQUAL)
{
GreaterEqual gte = new GreaterEqual();
pos += gte.read(tokenData,pos);
addOperator(gte);
}
else if (t == Token.NOT_EQUAL)
{
NotEqual ne = new NotEqual();
pos += ne.read(tokenData,pos);
addOperator(ne);
}
else if (t == Token.EQUAL)
{
Equal e = new Equal();
pos += e.read(tokenData,pos);
addOperator(e);
}
else if (t == Token.PARENTHESIS)
{
Parenthesis p = new Parenthesis();
pos += p.read(tokenData,pos);
addOperator(p);
}
// Functions
else if (t == Token.ATTRIBUTE)
{
Attribute a = new Attribute(settings);
pos += a.read(tokenData,pos);
if (a.isSum())
addOperator(a);
else if (a.isIf())
{
// Add it to a special stack for ifs
ifStack.Push(a);
}
}
else if (t == Token.FUNCTION)
{
BuiltInFunction bif = new BuiltInFunction(settings);
pos += bif.read(tokenData,pos);
addOperator(bif);
}
else if (t == Token.FUNCTIONVARARG)
{
VariableArgFunction vaf = new VariableArgFunction(settings);
pos += vaf.read(tokenData,pos);
if (vaf.getFunction() != Function.ATTRIBUTE)
addOperator(vaf);
else
{
// This is part of an IF function. Get the operands, but then
// add it to the top of the if stack
vaf.getOperands(tokenStack);
Attribute ifattr = null;
if (ifStack.Count == 0)
ifattr = new Attribute(settings);
else
ifattr = (Attribute)ifStack.Pop();
ifattr.setIfConditions(vaf);
tokenStack.Push(ifattr);
}
}
// Other things
else if (t == Token.MEM_FUNC)
{
MemFunc memFunc = new MemFunc();
handleMemoryFunction(memFunc);
}
else if (t == Token.MEM_AREA)
{
MemArea memArea = new MemArea();
handleMemoryFunction(memArea);
}
}
}
public virtual void VisitGreaterEqual(GreaterEqual n)
{
}
public SemanticAtom Visit(GreaterEqual n)
{
n.LeftExpression.Accept(this);
n.RightExpression.Accept(this);
return(null);
}
public virtual void VisitGreaterEqual(GreaterEqual n)
{
}
public SemanticAtom Visit(GreaterEqual n)
{
n.RealizedType = BinaryExpressionHelper(n, Primitive.Int, ">=", Primitive.Boolean);
return(n.RealizedType);
}
public void Visit(GreaterEqual node)
{
VisitChildren(node);
}
