Skip to content

Commit

Permalink
sql: Change token/opcode relative positions assertion to static
Browse files Browse the repository at this point in the history 
There are several token/opcode relative positions assertions in the sql codebase
and those tokens/opcodes are defined before the source compilation.
So it is possible to change those assertions to static ones.

Closes: tarantool#4240
  • Loading branch information
@Separador
Separador committed Aug 23, 2019
1 parent 5b9f207 commit d36d7c8
Show file tree
Hide file tree
Showing 3 changed files with 111 additions and 56 deletions.
105 changes: 70 additions & 35 deletions src/box/sql/expr.c
View file
Expand Up @@ -3839,22 +3839,28 @@ sqlExprCodeTarget(Parse * pParse, Expr * pExpr, int target)
&regFree2);
codeCompare(pParse, pLeft, pExpr->pRight, op,
r1, r2, inReg, SQL_STOREP2);
assert(TK_LT == OP_Lt);
static_assert(TK_LT == OP_Lt,
"inconsistent token/opcode definition");
testcase(op == OP_Lt);
VdbeCoverageIf(v, op == OP_Lt);
assert(TK_LE == OP_Le);
static_assert(TK_LE == OP_Le,
"inconsistent token/opcode definition");
testcase(op == OP_Le);
VdbeCoverageIf(v, op == OP_Le);
assert(TK_GT == OP_Gt);
static_assert(TK_GT == OP_Gt,
"inconsistent token/opcode definition");
testcase(op == OP_Gt);
VdbeCoverageIf(v, op == OP_Gt);
assert(TK_GE == OP_Ge);
static_assert(TK_GE == OP_Ge,
"inconsistent token/opcode definition");
testcase(op == OP_Ge);
VdbeCoverageIf(v, op == OP_Ge);
assert(TK_EQ == OP_Eq);
static_assert(TK_EQ == OP_Eq,
"inconsistent token/opcode definition");
testcase(op == OP_Eq);
VdbeCoverageIf(v, op == OP_Eq);
assert(TK_NE == OP_Ne);
static_assert(TK_NE == OP_Ne,
"inconsistent token/opcode definition");
testcase(op == OP_Ne);
VdbeCoverageIf(v, op == OP_Ne);
testcase(regFree1 == 0);
Expand All @@ -3874,27 +3880,38 @@ sqlExprCodeTarget(Parse * pParse, Expr * pExpr, int target)
case TK_LSHIFT:
case TK_RSHIFT:
case TK_CONCAT:{
assert(TK_AND == OP_And);
static_assert(TK_AND == OP_And,
"inconsistent token/opcode definition");
testcase(op == TK_AND);
assert(TK_OR == OP_Or);
static_assert(TK_OR == OP_Or,
"inconsistent token/opcode definition");
testcase(op == TK_OR);
assert(TK_PLUS == OP_Add);
static_assert(TK_PLUS == OP_Add,
"inconsistent token/opcode definition");
testcase(op == TK_PLUS);
assert(TK_MINUS == OP_Subtract);
static_assert(TK_MINUS == OP_Subtract,
"inconsistent token/opcode definition");
testcase(op == TK_MINUS);
assert(TK_REM == OP_Remainder);
static_assert(TK_REM == OP_Remainder,
"inconsistent token/opcode definition");
testcase(op == TK_REM);
assert(TK_BITAND == OP_BitAnd);
static_assert(TK_BITAND == OP_BitAnd,
"inconsistent token/opcode definition");
testcase(op == TK_BITAND);
assert(TK_BITOR == OP_BitOr);
static_assert(TK_BITOR == OP_BitOr,
"inconsistent token/opcode definition");
testcase(op == TK_BITOR);
assert(TK_SLASH == OP_Divide);
static_assert(TK_SLASH == OP_Divide,
"inconsistent token/opcode definition");
testcase(op == TK_SLASH);
assert(TK_LSHIFT == OP_ShiftLeft);
static_assert(TK_LSHIFT == OP_ShiftLeft,
"inconsistent token/opcode definition");
testcase(op == TK_LSHIFT);
assert(TK_RSHIFT == OP_ShiftRight);
static_assert(TK_RSHIFT == OP_ShiftRight,
"inconsistent token/opcode definition");
testcase(op == TK_RSHIFT);
assert(TK_CONCAT == OP_Concat);
static_assert(TK_CONCAT == OP_Concat,
"inconsistent token/opcode definition");
testcase(op == TK_CONCAT);
r1 = sqlExprCodeTemp(pParse, pExpr->pLeft,
&regFree1);
Expand Down Expand Up @@ -3931,9 +3948,11 @@ sqlExprCodeTarget(Parse * pParse, Expr * pExpr, int target)
}
case TK_BITNOT:
case TK_NOT:{
assert(TK_BITNOT == OP_BitNot);
static_assert(TK_BITNOT == OP_BitNot,
"inconsistent token/opcode definition");
testcase(op == TK_BITNOT);
assert(TK_NOT == OP_Not);
static_assert(TK_NOT == OP_Not,
"inconsistent token/opcode definition");
testcase(op == TK_NOT);
r1 = sqlExprCodeTemp(pParse, pExpr->pLeft,
&regFree1);
Expand All @@ -3944,9 +3963,11 @@ sqlExprCodeTarget(Parse * pParse, Expr * pExpr, int target)
case TK_ISNULL:
case TK_NOTNULL:{
int addr;
assert(TK_ISNULL == OP_IsNull);
static_assert(TK_ISNULL == OP_IsNull,
"inconsistent token/opcode definition");
testcase(op == TK_ISNULL);
assert(TK_NOTNULL == OP_NotNull);
static_assert(TK_NOTNULL == OP_NotNull,
"inconsistent token/opcode definition");
testcase(op == TK_NOTNULL);
sqlVdbeAddOp2(v, OP_Bool, true, target);
r1 = sqlExprCodeTemp(pParse, pExpr->pLeft,
Expand Down Expand Up @@ -4759,25 +4780,31 @@ sqlExprIfTrue(Parse * pParse, Expr * pExpr, int dest, int jumpIfNull)
&regFree2);
codeCompare(pParse, pExpr->pLeft, pExpr->pRight, op, r1,
r2, dest, jumpIfNull);
assert(TK_LT == OP_Lt);
static_assert(TK_LT == OP_Lt,
"inconsistent token/opcode definition");
testcase(op == OP_Lt);
VdbeCoverageIf(v, op == OP_Lt);
assert(TK_LE == OP_Le);
static_assert(TK_LE == OP_Le,
"inconsistent token/opcode definition");
testcase(op == OP_Le);
VdbeCoverageIf(v, op == OP_Le);
assert(TK_GT == OP_Gt);
static_assert(TK_GT == OP_Gt,
"inconsistent token/opcode definition");
testcase(op == OP_Gt);
VdbeCoverageIf(v, op == OP_Gt);
assert(TK_GE == OP_Ge);
static_assert(TK_GE == OP_Ge,
"inconsistent token/opcode definition");
testcase(op == OP_Ge);
VdbeCoverageIf(v, op == OP_Ge);
assert(TK_EQ == OP_Eq);
static_assert(TK_EQ == OP_Eq,
"inconsistent token/opcode definition");
testcase(op == OP_Eq);
VdbeCoverageIf(v, op == OP_Eq
&& jumpIfNull == SQL_NULLEQ);
VdbeCoverageIf(v, op == OP_Eq
&& jumpIfNull != SQL_NULLEQ);
assert(TK_NE == OP_Ne);
static_assert(TK_NE == OP_Ne,
"inconsistent token/opcode definition");
testcase(op == OP_Ne);
VdbeCoverageIf(v, op == OP_Ne
&& jumpIfNull == SQL_NULLEQ);
Expand All @@ -4789,9 +4816,11 @@ sqlExprIfTrue(Parse * pParse, Expr * pExpr, int dest, int jumpIfNull)
}
case TK_ISNULL:
case TK_NOTNULL:{
assert(TK_ISNULL == OP_IsNull);
static_assert(TK_ISNULL == OP_IsNull,
"inconsistent token/opcode definition");
testcase(op == TK_ISNULL);
assert(TK_NOTNULL == OP_NotNull);
static_assert(TK_NOTNULL == OP_NotNull,
"inconsistent token/opcode definition");
testcase(op == TK_NOTNULL);
r1 = sqlExprCodeTemp(pParse, pExpr->pLeft,
&regFree1);
Expand Down Expand Up @@ -4952,25 +4981,31 @@ sqlExprIfFalse(Parse * pParse, Expr * pExpr, int dest, int jumpIfNull)
&regFree2);
codeCompare(pParse, pExpr->pLeft, pExpr->pRight, op, r1,
r2, dest, jumpIfNull);
assert(TK_LT == OP_Lt);
static_assert(TK_LT == OP_Lt,
"inconsistent token/opcode definition");
testcase(op == OP_Lt);
VdbeCoverageIf(v, op == OP_Lt);
assert(TK_LE == OP_Le);
static_assert(TK_LE == OP_Le,
"inconsistent token/opcode definition");
testcase(op == OP_Le);
VdbeCoverageIf(v, op == OP_Le);
assert(TK_GT == OP_Gt);
static_assert(TK_GT == OP_Gt,
"inconsistent token/opcode definition");
testcase(op == OP_Gt);
VdbeCoverageIf(v, op == OP_Gt);
assert(TK_GE == OP_Ge);
static_assert(TK_GE == OP_Ge,
"inconsistent token/opcode definition");
testcase(op == OP_Ge);
VdbeCoverageIf(v, op == OP_Ge);
assert(TK_EQ == OP_Eq);
static_assert(TK_EQ == OP_Eq,
"inconsistent token/opcode definition");
testcase(op == OP_Eq);
VdbeCoverageIf(v, op == OP_Eq
&& jumpIfNull != SQL_NULLEQ);
VdbeCoverageIf(v, op == OP_Eq
&& jumpIfNull == SQL_NULLEQ);
assert(TK_NE == OP_Ne);
static_assert(TK_NE == OP_Ne,
"inconsistent token/opcode definition");
testcase(op == OP_Ne);
VdbeCoverageIf(v, op == OP_Ne
&& jumpIfNull != SQL_NULLEQ);
Expand Down
33 changes: 22 additions & 11 deletions src/box/sql/vdbe.c
View file
Expand Up @@ -1847,7 +1847,8 @@ case OP_ShiftRight: { /* same as TK_RSHIFT, in1, in2, out3 */

/* If shifting by a negative amount, shift in the other direction */
if (iB<0) {
assert(OP_ShiftRight==OP_ShiftLeft+1);
static_assert(OP_ShiftRight==OP_ShiftLeft+1,
"inconsistent opcode definition");
op = 2*OP_ShiftLeft + 1 - op;
iB = iB>(-64) ? -iB : 64;
}
Expand Down Expand Up @@ -3280,9 +3281,12 @@ case OP_SeekGT: { /* jump, in3 */
pC = p->apCsr[pOp->p1];
assert(pC!=0);
assert(pC->eCurType==CURTYPE_TARANTOOL);
assert(OP_SeekLE == OP_SeekLT+1);
assert(OP_SeekGE == OP_SeekLT+2);
assert(OP_SeekGT == OP_SeekLT+3);
static_assert(OP_SeekLE == OP_SeekLT+1,
"inconsistent opcode definition");
static_assert(OP_SeekGE == OP_SeekLT+2,
"inconsistent opcode definition");
static_assert(OP_SeekGT == OP_SeekLT+3,
"inconsistent opcode definition");
assert(pC->uc.pCursor!=0);
oc = pOp->opcode;
eqOnly = 0;
Expand Down Expand Up @@ -3352,19 +3356,25 @@ case OP_SeekGT: { /* jump, in3 */
* (x <= 4.9) -> (x < 5)
*/
if (pIn3->u.r<(double)iKey) {
assert(OP_SeekGE==(OP_SeekGT-1));
assert(OP_SeekLT==(OP_SeekLE-1));
assert((OP_SeekLE & 0x0001)==(OP_SeekGT & 0x0001));
static_assert(OP_SeekGE==(OP_SeekGT-1),
"inconsistent opcode definition");
static_assert(OP_SeekLT==(OP_SeekLE-1),
"inconsistent opcode definition");
static_assert((OP_SeekLE & 0x0001)==(OP_SeekGT & 0x0001),
"inconsistent opcode definition");
if ((oc & 0x0001)==(OP_SeekGT & 0x0001)) oc--;
}

/* If the approximation iKey is smaller than the actual real search
* term, substitute <= for < and > for >=.
*/
else if (pIn3->u.r>(double)iKey) {
assert(OP_SeekLE==(OP_SeekLT+1));
assert(OP_SeekGT==(OP_SeekGE+1));
assert((OP_SeekLT & 0x0001)==(OP_SeekGE & 0x0001));
static_assert(OP_SeekLE==(OP_SeekLT+1),
"inconsistent opcode definition");
static_assert(OP_SeekGT==(OP_SeekGE+1),
"inconsistent opcode definition");
static_assert((OP_SeekLT & 0x0001)==(OP_SeekGE & 0x0001),
"inconsistent opcode definition");
if ((oc & 0x0001)==(OP_SeekLT & 0x0001)) oc++;
}
}
Expand Down Expand Up @@ -4529,7 +4539,8 @@ case OP_IdxGE: { /* jump */
{ int i; for(i=0; i<r.nField; i++) assert(memIsValid(&r.aMem[i])); }
#endif
int res = tarantoolsqlIdxKeyCompare(pC->uc.pCursor, &r);
assert((OP_IdxLE&1)==(OP_IdxLT&1) && (OP_IdxGE&1)==(OP_IdxGT&1));
static_assert((OP_IdxLE&1)==(OP_IdxLT&1) && (OP_IdxGE&1)==(OP_IdxGT&1),
"inconsistent opcode definition");
if ((pOp->opcode&1)==(OP_IdxLT&1)) {
assert(pOp->opcode==OP_IdxLE || pOp->opcode==OP_IdxLT);
res = -res;
Expand Down
29 changes: 19 additions & 10 deletions src/box/sql/whereexpr.c
View file
Expand Up @@ -132,10 +132,14 @@ whereClauseInsert(WhereClause * pWC, Expr * p, u16 wtFlags)
static int
allowedOp(int op)
{
assert(TK_GT > TK_EQ && TK_GT < TK_GE);
assert(TK_LT > TK_EQ && TK_LT < TK_GE);
assert(TK_LE > TK_EQ && TK_LE < TK_GE);
assert(TK_GE == TK_EQ + 4);
static_assert(TK_GT > TK_EQ && TK_GT < TK_GE,
"inconsistent token definition");
static_assert(TK_LT > TK_EQ && TK_LT < TK_GE,
"inconsistent token definition");
static_assert(TK_LE > TK_EQ && TK_LE < TK_GE,
"inconsistent token definition");
static_assert(TK_GE == TK_EQ + 4,
"inconsistent token definition");
return op == TK_IN || (op >= TK_EQ && op <= TK_GE) || op == TK_ISNULL;
}

Expand Down Expand Up @@ -186,10 +190,14 @@ exprCommute(Parse * pParse, Expr * pExpr)
}
SWAP(pExpr->pRight, pExpr->pLeft);
if (pExpr->op >= TK_GT) {
assert(TK_LT == TK_GT + 2);
assert(TK_GE == TK_LE + 2);
assert(TK_GT > TK_EQ);
assert(TK_GT < TK_LE);
static_assert(TK_LT == TK_GT + 2,
"inconsistent token definition");
static_assert(TK_GE == TK_LE + 2,
"inconsistent token definition");
static_assert(TK_GT > TK_EQ,
"inconsistent token definition");
static_assert(TK_GT < TK_LE,
"inconsistent token definition");
assert(pExpr->op >= TK_GT && pExpr->op <= TK_GE);
pExpr->op = ((pExpr->op - TK_GT) ^ 2) + TK_GT;
}
Expand Down Expand Up @@ -945,8 +953,9 @@ exprMightBeIndexed(int op, /* The specific comparison operator */
* inequality constraint (>, <, >= or <=), perform the processing
* on the first element of the vector.
*/
assert(TK_GT + 1 == TK_LE && TK_GT + 2 == TK_LT && TK_GT + 3 == TK_GE);
assert(TK_IN < TK_GE);
static_assert(TK_GT + 1 == TK_LE && TK_GT + 2 == TK_LT && TK_GT + 3 == TK_GE,
"inconsistent token definition");
static_assert(TK_IN < TK_GE, "inconsistent token definition");
assert(op <= TK_GE || op == TK_ISNULL || op == TK_NOTNULL);
if (pExpr->op == TK_VECTOR && (op >= TK_GT && op <= TK_GE)) {
pExpr = pExpr->x.pList->a[0].pExpr;
Expand Down

0 comments on commit d36d7c8

Please sign in to comment.