rename the following methods:

tqparent parent
tqmask mask

8 files changed, 89 insertions, 89 deletions

diff --git a/tqtinterface/qt4/src/3rdparty/sqlite/btree.c b/tqtinterface/qt4/src/3rdparty/sqlite/btree.c
index c7143e0..3ff88f6 100644
--- a/tqtinterface/qt4/src/3rdparty/sqlite/btree.c
+++ b/tqtinterface/qt4/src/3rdparty/sqlite/btree.c
@@ -313,9 +313,9 @@ struct FreelistInfo {
 ** page to hold as many as two more cells than it might otherwise hold.
 ** The extra two entries in apCell[] are an allowance for this situation.
 **
-** The pParent field points back to the tqparent page.  This allows us to
+** The pParent field points back to the parent page.  This allows us to
 ** walk up the BTree from any leaf to the root.  Care must be taken to
-** unref() the tqparent page pointer when this page is no longer referenced.
+** unref() the parent page pointer when this page is no longer referenced.
 ** The pageDestructor() routine handles that chore.
 */
 struct MemPage {
@@ -326,7 +326,7 @@ struct MemPage {
   u8 isInit;                     /* True if auxiliary data is initialized */
   u8 idxShift;                   /* True if apCell[] indices have changed */
   u8 isOverfull;                 /* Some apCell[] points outside u.aDisk[] */
-  MemPage *pParent;              /* The tqparent of this page.  NULL for root */
+  MemPage *pParent;              /* The parent of this page.  NULL for root */
   int idxParent;                 /* Index in pParent->apCell[] of this node */
   int nFree;                     /* Number of free bytes in u.aDisk[] */
   int nCell;                     /* Number of entries on this page */
@@ -567,8 +567,8 @@ static void freeSpace(Btree *pBt, MemPage *pPage, int start, int size){
 ** Initialize the auxiliary information for a disk block.
 **
 ** The pParent parameter must be a pointer to the MemPage which
-** is the tqparent of the page being initialized.  The root of the
-** BTree (usually page 2) has no tqparent and so for that page, 
+** is the parent of the page being initialized.  The root of the
+** BTree (usually page 2) has no parent and so for that page, 
 ** pParent==NULL.
 **
 ** Return STQLITE_OK on success.  If we see that the page does
@@ -1409,7 +1409,7 @@ static int moveToChild(BtCursor *pCur, int newPgno){
 }
 
 /*
-** Move the cursor up to the tqparent page.
+** Move the cursor up to the parent page.
 **
 ** pCur->idx is set to the cell index that contains the pointer
 ** to the page we are coming from.  If we are coming from the
@@ -1446,7 +1446,7 @@ static void moveToParent(BtCursor *pCur){
   }else{
     /* The MemPage.idxShift flag indicates that cell indices might have 
     ** changed since idxParent was set and hence idxParent might be out
-    ** of date.  So recompute the tqparent cell index by scanning all cells
+    ** of date.  So recompute the parent cell index by scanning all cells
     ** and locating the one that points to the child we just came from.
     */
     int i;
@@ -1993,9 +1993,9 @@ static void reparentPage(Pager *pPager, Pgno pgno, MemPage *pNewParent,int idx){
 }
 
 /*
-** Retqparent all tqchildren of the given page to be the given page.
+** Reparent all tqchildren of the given page to be the given page.
 ** In other words, for every child of pPage, invoke reparentPage()
-** to make sure that each child knows that pPage is its tqparent.
+** to make sure that each child knows that pPage is its parent.
 **
 ** This routine gets called after you memcpy() one page into
 ** another.
@@ -2136,7 +2136,7 @@ static void copyPage(MemPage *pTo, MemPage *pFrom){
 ** of pPage so that all pages have about the same amount of free space.
 ** Usually one sibling on either side of pPage is used in the balancing,
 ** though both siblings might come from one side if pPage is the first
-** or last child of its tqparent.  If pPage has fewer than two siblings
+** or last child of its parent.  If pPage has fewer than two siblings
 ** (something which can only happen if pPage is the root page or a 
 ** child of root) then all available siblings participate in the balancing.
 **
@@ -2163,16 +2163,16 @@ static void copyPage(MemPage *pTo, MemPage *pFrom){
 ** if the page is overfull.  Part of the job of this routine is to
 ** make sure all Cells for pPage once again fit in pPage->u.aDisk[].
 **
-** In the course of balancing the siblings of pPage, the tqparent of pPage
+** In the course of balancing the siblings of pPage, the parent of pPage
 ** might become overfull or underfull.  If that happens, then this routine
-** is called recursively on the tqparent.
+** is called recursively on the parent.
 **
 ** If this routine fails for any reason, it might leave the database
 ** in a corrupted state.  So if this routine fails, the database should
 ** be rolled back.
 */
 static int balance(Btree *pBt, MemPage *pPage, BtCursor *pCur){
-  MemPage *pParent;            /* The tqparent of pPage */
+  MemPage *pParent;            /* The parent of pPage */
   int nCell;                   /* Number of cells in apCell[] */
   int nOld;                    /* Number of pages in apOld[] */
   int nNew;                    /* Number of pages in apNew[] */
@@ -2210,8 +2210,8 @@ static int balance(Btree *pBt, MemPage *pPage, BtCursor *pCur){
   }
 
   /*
-  ** Find the tqparent of the page to be balanceed.
-  ** If there is no tqparent, it means this page is the root page and
+  ** Find the parent of the page to be balanceed.
+  ** If there is no parent, it means this page is the root page and
   ** special rules apply.
   */
   pParent = pPage->pParent;
@@ -2286,7 +2286,7 @@ static int balance(Btree *pBt, MemPage *pPage, BtCursor *pCur){
   assert( pParent->isInit );
   
   /*
-  ** Find the Cell in the tqparent page whose h.leftChild points back
+  ** Find the Cell in the parent page whose h.leftChild points back
   ** to pPage.  The "idx" variable is the index of that cell.  If pPage
   ** is the rightmost child of pParent then set idx to pParent->nCell 
   */
@@ -2542,7 +2542,7 @@ static int balance(Btree *pBt, MemPage *pPage, BtCursor *pCur){
   }
 
   /*
-  ** Retqparent tqchildren of all cells.
+  ** Reparent tqchildren of all cells.
   */
   for(i=0; i<nNew; i++){
     reparentChildPages(pBt, apNew[i]);
@@ -2550,7 +2550,7 @@ static int balance(Btree *pBt, MemPage *pPage, BtCursor *pCur){
   reparentChildPages(pBt, pParent);
 
   /*
-  ** balance the tqparent page.
+  ** balance the parent page.
   */
   rc = balance(pBt, pParent, pCur);
 
diff --git a/tqtinterface/qt4/src/3rdparty/sqlite/btree_rb.c b/tqtinterface/qt4/src/3rdparty/sqlite/btree_rb.c
index fd81df2..e952b7a 100644
--- a/tqtinterface/qt4/src/3rdparty/sqlite/btree_rb.c
+++ b/tqtinterface/qt4/src/3rdparty/sqlite/btree_rb.c
@@ -123,7 +123,7 @@ struct BtRbNode {
   int nData;
   void *pData;
   u8 isBlack;        /* true for a black node, 0 for a red node */
-  BtRbNode *pParent; /* Nodes tqparent node, NULL for the tree head */
+  BtRbNode *pParent; /* Nodes parent node, NULL for the tree head */
   BtRbNode *pLeft;   /* Nodes left child, or NULL */
   BtRbNode *pRight;  /* Nodes right child, or NULL */
 
@@ -329,7 +329,7 @@ static void check_redblack_tree(BtRbTree * tree, char ** msg)
 {
   BtRbNode *pNode;
 
-  /* 0 -> came from tqparent 
+  /* 0 -> came from parent 
    * 1 -> came from left
    * 2 -> came from right */
   int prev_step = 0;
@@ -400,34 +400,34 @@ static void check_redblack_tree(BtRbTree * tree, char ** msg)
 
 /*
  * Node pX has just been inserted into pTree (by code in sqliteRbtreeInsert()).
- * It is possible that pX is a red node with a red tqparent, which is a violation
+ * It is possible that pX is a red node with a red parent, which is a violation
  * of the red-black tree properties. This function performs rotations and 
  * color changes to rebalance the tree
  */
 static void do_insert_balancing(BtRbTree *pTree, BtRbNode *pX)
 {
   /* In the first iteration of this loop, pX points to the red node just
-   * inserted in the tree. If the tqparent of pX exists (pX is not the root
+   * inserted in the tree. If the parent of pX exists (pX is not the root
    * node) and is red, then the properties of the red-black tree are
    * violated.
    *
    * At the start of any subsequent iterations, pX points to a red node
-   * with a red tqparent. In all other respects the tree is a legal red-black
+   * with a red parent. In all other respects the tree is a legal red-black
    * binary tree. */
   while( pX != pTree->pHead && !pX->pParent->isBlack ){
     BtRbNode *pUncle;
-    BtRbNode *pGrandtqparent;
+    BtRbNode *pGrandparent;
 
-    /* Grandtqparent of pX must exist and must be black. */
-    pGrandtqparent = pX->pParent->pParent;
-    assert( pGrandtqparent );
-    assert( pGrandtqparent->isBlack );
+    /* Grandparent of pX must exist and must be black. */
+    pGrandparent = pX->pParent->pParent;
+    assert( pGrandparent );
+    assert( pGrandparent->isBlack );
 
     /* Uncle of pX may or may not exist. */
-    if( pX->pParent == pGrandtqparent->pLeft ) 
-      pUncle = pGrandtqparent->pRight;
+    if( pX->pParent == pGrandparent->pLeft ) 
+      pUncle = pGrandparent->pRight;
     else 
-      pUncle = pGrandtqparent->pLeft;
+      pUncle = pGrandparent->pLeft;
 
     /* If the uncle of pX exists and is red, we do the following:
      *       |                 |
@@ -438,16 +438,16 @@ static void do_insert_balancing(BtRbTree *pTree, BtRbNode *pX)
      *           X(r)              X(r)
      *
      *     BEFORE             AFTER
-     * pX is then set to G. If the tqparent of G is red, then the while loop
+     * pX is then set to G. If the parent of G is red, then the while loop
      * will run again.  */
     if( pUncle && !pUncle->isBlack ){
-      pGrandtqparent->isBlack = 0;
+      pGrandparent->isBlack = 0;
       pUncle->isBlack = 1;
       pX->pParent->isBlack = 1;
-      pX = pGrandtqparent;
+      pX = pGrandparent;
     }else{
 
-      if( pX->pParent == pGrandtqparent->pLeft ){
+      if( pX->pParent == pGrandparent->pLeft ){
         if( pX == pX->pParent->pRight ){
           /* If pX is a right-child, do the following transform, essentially
            * to change pX into a left-child: 
@@ -474,10 +474,10 @@ static void do_insert_balancing(BtRbTree *pTree, BtRbNode *pX)
          *
          *     BEFORE             AFTER
          */
-        assert( pGrandtqparent == pX->pParent->pParent );
-        pGrandtqparent->isBlack = 0;
+        assert( pGrandparent == pX->pParent->pParent );
+        pGrandparent->isBlack = 0;
         pX->pParent->isBlack = 1;
-        rightRotate( pTree, pGrandtqparent );
+        rightRotate( pTree, pGrandparent );
 
       }else{
         /* This code is symetric to the illustrated case above. */
@@ -485,10 +485,10 @@ static void do_insert_balancing(BtRbTree *pTree, BtRbNode *pX)
           pX = pX->pParent;
           rightRotate(pTree, pX);
         }
-        assert( pGrandtqparent == pX->pParent->pParent );
-        pGrandtqparent->isBlack = 0;
+        assert( pGrandparent == pX->pParent->pParent );
+        pGrandparent->isBlack = 0;
         pX->pParent->isBlack = 1;
-        leftRotate( pTree, pGrandtqparent );
+        leftRotate( pTree, pGrandparent );
       }
     }
   }
diff --git a/tqtinterface/qt4/src/3rdparty/sqlite/func.c b/tqtinterface/qt4/src/3rdparty/sqlite/func.c
index 8d78e12..529b169 100644
--- a/tqtinterface/qt4/src/3rdparty/sqlite/func.c
+++ b/tqtinterface/qt4/src/3rdparty/sqlite/func.c
@@ -32,10 +32,10 @@ static void minmaxFunc(sqlite_func *context, int argc, const char **argv){
   const char *zBest; 
   int i;
   int (*xCompare)(const char*, const char*);
-  int tqmask;    /* 0 for min() or 0xffffffff for max() */
+  int mask;    /* 0 for min() or 0xffffffff for max() */
 
   if( argc==0 ) return;
-  tqmask = (int)sqlite_user_data(context);
+  mask = (int)sqlite_user_data(context);
   zBest = argv[0];
   if( zBest==0 ) return;
   if( argv[1][0]=='n' ){
@@ -45,7 +45,7 @@ static void minmaxFunc(sqlite_func *context, int argc, const char **argv){
   }
   for(i=2; i<argc; i+=2){
     if( argv[i]==0 ) return;
-    if( (xCompare(argv[i], zBest)^tqmask)<0 ){
+    if( (xCompare(argv[i], zBest)^mask)<0 ){
       zBest = argv[i];
     }
   }
@@ -514,7 +514,7 @@ struct MinMaxCtx {
 static void minmaxStep(sqlite_func *context, int argc, const char **argv){
   MinMaxCtx *p;
   int (*xCompare)(const char*, const char*);
-  int tqmask;    /* 0 for min() or 0xffffffff for max() */
+  int mask;    /* 0 for min() or 0xffffffff for max() */
 
   assert( argc==2 );
   if( argv[1][0]=='n' ){
@@ -522,10 +522,10 @@ static void minmaxStep(sqlite_func *context, int argc, const char **argv){
   }else{
     xCompare = strcmp;
   }
-  tqmask = (int)sqlite_user_data(context);
+  mask = (int)sqlite_user_data(context);
   p = sqlite_aggregate_context(context, sizeof(*p));
   if( p==0 || argc<1 || argv[0]==0 ) return;
-  if( p->z==0 || (xCompare(argv[0],p->z)^tqmask)<0 ){
+  if( p->z==0 || (xCompare(argv[0],p->z)^mask)<0 ){
     int len;
     if( !p->zBuf[0] ){
       sqliteFree(p->z);
diff --git a/tqtinterface/qt4/src/3rdparty/sqlite/parse.c b/tqtinterface/qt4/src/3rdparty/sqlite/parse.c
index 7ead48a..5ecb220 100644
--- a/tqtinterface/qt4/src/3rdparty/sqlite/parse.c
+++ b/tqtinterface/qt4/src/3rdparty/sqlite/parse.c
@@ -97,7 +97,7 @@ typedef union {
   IdList* yy320;
   ExprList* yy322;
   int yy372;
-  struct {int value; int tqmask;} yy407;
+  struct {int value; int mask;} yy407;
   int yy441;
 } YYMINORTYPE;
 #define YYSTACKDEPTH 100
@@ -2218,33 +2218,33 @@ static void yy_reduce(
         break;
       case 62:
 #line 207 "parse.y"
-{ yygotominor.yy372 = (yymsp[-1].minor.yy372 & yymsp[0].minor.yy407.tqmask) | yymsp[0].minor.yy407.value; }
+{ yygotominor.yy372 = (yymsp[-1].minor.yy372 & yymsp[0].minor.yy407.mask) | yymsp[0].minor.yy407.value; }
 #line 2222 "parse.c"
         break;
       case 63:
 #line 209 "parse.y"
-{ yygotominor.yy407.value = 0;     yygotominor.yy407.tqmask = 0x000000; }
+{ yygotominor.yy407.value = 0;     yygotominor.yy407.mask = 0x000000; }
 #line 2227 "parse.c"
         /* No destructor defined for MATCH */
         /* No destructor defined for nm */
         break;
       case 64:
 #line 210 "parse.y"
-{ yygotominor.yy407.value = yymsp[0].minor.yy372;     yygotominor.yy407.tqmask = 0x0000ff; }
+{ yygotominor.yy407.value = yymsp[0].minor.yy372;     yygotominor.yy407.mask = 0x0000ff; }
 #line 2234 "parse.c"
         /* No destructor defined for ON */
         /* No destructor defined for DELETE */
         break;
       case 65:
 #line 211 "parse.y"
-{ yygotominor.yy407.value = yymsp[0].minor.yy372<<8;  yygotominor.yy407.tqmask = 0x00ff00; }
+{ yygotominor.yy407.value = yymsp[0].minor.yy372<<8;  yygotominor.yy407.mask = 0x00ff00; }
 #line 2241 "parse.c"
         /* No destructor defined for ON */
         /* No destructor defined for UPDATE */
         break;
       case 66:
 #line 212 "parse.y"
-{ yygotominor.yy407.value = yymsp[0].minor.yy372<<16; yygotominor.yy407.tqmask = 0xff0000; }
+{ yygotominor.yy407.value = yymsp[0].minor.yy372<<16; yygotominor.yy407.mask = 0xff0000; }
 #line 2248 "parse.c"
         /* No destructor defined for ON */
         /* No destructor defined for INSERT */
diff --git a/tqtinterface/qt4/src/3rdparty/sqlite/pragma.c b/tqtinterface/qt4/src/3rdparty/sqlite/pragma.c
index 28f8390..6534766 100644
--- a/tqtinterface/qt4/src/3rdparty/sqlite/pragma.c
+++ b/tqtinterface/qt4/src/3rdparty/sqlite/pragma.c
@@ -91,7 +91,7 @@ static int getTempStore(char *z){
 static int flagPragma(Parse *pParse, const char *zLeft, const char *zRight){
   static const struct {
     const char *zName;  /* Name of the pragma */
-    int tqmask;           /* Mask for the db->flags value */
+    int mask;           /* Mask for the db->flags value */
   } aPragma[] = {
     { "vdbe_trace",               STQLITE_VdbeTrace     },
     { "full_column_names",        STQLITE_FullColNames  },
@@ -108,13 +108,13 @@ static int flagPragma(Parse *pParse, const char *zLeft, const char *zRight){
       if( strcmp(zLeft,zRight)==0 && (v = sqliteGetVdbe(pParse))!=0 ){
         sqliteVdbeOp3(v, OP_ColumnName, 0, 1, aPragma[i].zName, P3_STATIC);
         sqliteVdbeOp3(v, OP_ColumnName, 1, 0, "boolean", P3_STATIC);
-        sqliteVdbeCode(v, OP_Integer, (db->flags & aPragma[i].tqmask)!=0, 0,
+        sqliteVdbeCode(v, OP_Integer, (db->flags & aPragma[i].mask)!=0, 0,
                           OP_Callback, 1, 0,
                           0);
       }else if( getBoolean(zRight) ){
-        db->flags |= aPragma[i].tqmask;
+        db->flags |= aPragma[i].mask;
       }else{
-        db->flags &= ~aPragma[i].tqmask;
+        db->flags &= ~aPragma[i].mask;
       }
       return 1;
     }
diff --git a/tqtinterface/qt4/src/3rdparty/sqlite/select.c b/tqtinterface/qt4/src/3rdparty/sqlite/select.c
index 21416aa..d29c4a5 100644
--- a/tqtinterface/qt4/src/3rdparty/sqlite/select.c
+++ b/tqtinterface/qt4/src/3rdparty/sqlite/select.c
@@ -1618,7 +1618,7 @@ substExprList(ExprList *pList, int iTable, ExprList *pEList){
 */
 static int flattenSubquery(
   Parse *pParse,       /* The parsing context */
-  Select *p,           /* The tqparent or outer SELECT statement */
+  Select *p,           /* The parent or outer SELECT statement */
   int iFrom,           /* Index in p->pSrc->a[] of the inner subquery */
   int isAgg,           /* True if outer SELECT uses aggregate functions */
   int subqueryIsAgg    /* True if the subquery uses aggregate functions */
@@ -1957,8 +1957,8 @@ static int simpleMinMaxQuery(Parse *pParse, Select *p, int eDest, int iParm){
 **
 ** The pParent, parentTab, and *pParentAgg fields are filled in if this
 ** SELECT is a subquery.  This routine may try to combine this SELECT
-** with its tqparent to form a single flat query.  In so doing, it might
-** change the tqparent query from a non-aggregate to an aggregate query.
+** with its parent to form a single flat query.  In so doing, it might
+** change the parent query from a non-aggregate to an aggregate query.
 ** For that reason, the pParentAgg flag is passed as a pointer, so it
 ** can be changed.
 **
@@ -2198,7 +2198,7 @@ int sqliteSelect(
     isDistinct = p->isDistinct;
   }
 
-  /* Check to see if this is a subquery that can be "flattened" into its tqparent.
+  /* Check to see if this is a subquery that can be "flattened" into its parent.
   ** If flattening is a possiblity, do so and return immediately.  
   */
   if( pParent && pParentAgg &&
@@ -2379,7 +2379,7 @@ int sqliteSelect(
   }
 
   /* If this was a subquery, we have now converted the subquery into a
-  ** temporary table.  So delete the subquery structure from the tqparent
+  ** temporary table.  So delete the subquery structure from the parent
   ** to prevent this subquery from being evaluated again and to force the
   ** the use of the temporary table.
   */
diff --git a/tqtinterface/qt4/src/3rdparty/sqlite/sqliteInt.h b/tqtinterface/qt4/src/3rdparty/sqlite/sqliteInt.h
index aea8271..3f713cd 100644
--- a/tqtinterface/qt4/src/3rdparty/sqlite/sqliteInt.h
+++ b/tqtinterface/qt4/src/3rdparty/sqlite/sqliteInt.h
@@ -1049,9 +1049,9 @@ struct TriggerStep {
  *
  * struct TriggerStack has a "pNext" member, to allow linked lists to be
  * constructed. When coding nested triggers (triggers fired by other triggers)
- * each nested trigger stores its tqparent trigger's TriggerStack as the "pNext" 
+ * each nested trigger stores its parent trigger's TriggerStack as the "pNext" 
  * pointer. Once the nested trigger has been coded, the pNext value is restored
- * to the pTriggerStack member of the Parse stucture and coding of the tqparent
+ * to the pTriggerStack member of the Parse stucture and coding of the parent
  * trigger continues.
  *
  * Before a nested trigger is coded, the linked list pointed to by the 
diff --git a/tqtinterface/qt4/src/3rdparty/sqlite/where.c b/tqtinterface/qt4/src/3rdparty/sqlite/where.c
index 3ab7eca..c849d1c 100644
--- a/tqtinterface/qt4/src/3rdparty/sqlite/where.c
+++ b/tqtinterface/qt4/src/3rdparty/sqlite/where.c
@@ -29,9 +29,9 @@ struct ExprInfo {
                           ** p->pLeft is not the column of any table */
   short int idxRight;     /* p->pRight is a column in this table number. -1 if
                           ** p->pRight is not the column of any table */
-  unsigned prereqLeft;    /* Bittqmask of tables referenced by p->pLeft */
-  unsigned prereqRight;   /* Bittqmask of tables referenced by p->pRight */
-  unsigned prereqAll;     /* Bittqmask of tables referenced by p */
+  unsigned prereqLeft;    /* Bitmask of tables referenced by p->pLeft */
+  unsigned prereqRight;   /* Bitmask of tables referenced by p->pRight */
+  unsigned prereqAll;     /* Bitmask of tables referenced by p */
 };
 
 /*
@@ -81,12 +81,12 @@ static int exprSplit(int nSlot, ExprInfo *aSlot, Expr *pExpr){
 }
 
 /*
-** Initialize an expression tqmask set
+** Initialize an expression mask set
 */
 #define initMaskSet(P)  memset(P, 0, sizeof(*P))
 
 /*
-** Return the bittqmask for the given cursor.  Assign a new bittqmask
+** Return the bitmask for the given cursor.  Assign a new bitmask
 ** if this is the first time the cursor has been seen.
 */
 static int getMask(ExprMaskSet *pMaskSet, int iCursor){
@@ -103,13 +103,13 @@ static int getMask(ExprMaskSet *pMaskSet, int iCursor){
 }
 
 /*
-** Destroy an expression tqmask set
+** Destroy an expression mask set
 */
 #define freeMaskSet(P)   /* NO-OP */
 
 /*
 ** This routine walks (recursively) an expression tree and generates
-** a bittqmask indicating which tables are used in that expression
+** a bitmask indicating which tables are used in that expression
 ** tree.
 **
 ** In order for this routine to work, the calling function must have
@@ -120,24 +120,24 @@ static int getMask(ExprMaskSet *pMaskSet, int iCursor){
 ** the VDBE cursor number of the table.
 */
 static int exprTableUsage(ExprMaskSet *pMaskSet, Expr *p){
-  unsigned int tqmask = 0;
+  unsigned int mask = 0;
   if( p==0 ) return 0;
   if( p->op==TK_COLUMN ){
     return getMask(pMaskSet, p->iTable);
   }
   if( p->pRight ){
-    tqmask = exprTableUsage(pMaskSet, p->pRight);
+    mask = exprTableUsage(pMaskSet, p->pRight);
   }
   if( p->pLeft ){
-    tqmask |= exprTableUsage(pMaskSet, p->pLeft);
+    mask |= exprTableUsage(pMaskSet, p->pLeft);
   }
   if( p->pList ){
     int i;
     for(i=0; i<p->pList->nExpr; i++){
-      tqmask |= exprTableUsage(pMaskSet, p->pList->a[i].pExpr);
+      mask |= exprTableUsage(pMaskSet, p->pList->a[i].pExpr);
     }
   }
-  return tqmask;
+  return mask;
 }
 
 /*
@@ -360,7 +360,7 @@ WhereInfo *sqliteWhereBegin(
   int nExpr;           /* Number of subexpressions in the WHERE clause */
   int loopMask;        /* One bit set for each outer loop */
   int haveKey;         /* True if KEY is on the stack */
-  ExprMaskSet maskSet; /* The expression tqmask set */
+  ExprMaskSet maskSet; /* The expression mask set */
   int iDirectEq[32];   /* Term of the form ROWID==X for the N-th table */
   int iDirectLt[32];   /* Term of the form ROWID<X or ROWID<=X */
   int iDirectGt[32];   /* Term of the form ROWID>X or ROWID>=X */
@@ -417,16 +417,16 @@ WhereInfo *sqliteWhereBegin(
     if( pParse->trigStack ){
       int x;
       if( (x = pParse->trigStack->newIdx) >= 0 ){
-        int tqmask = ~getMask(&maskSet, x);
-        aExpr[i].prereqRight &= tqmask;
-        aExpr[i].prereqLeft &= tqmask;
-        aExpr[i].prereqAll &= tqmask;
+        int mask = ~getMask(&maskSet, x);
+        aExpr[i].prereqRight &= mask;
+        aExpr[i].prereqLeft &= mask;
+        aExpr[i].prereqAll &= mask;
       }
       if( (x = pParse->trigStack->oldIdx) >= 0 ){
-        int tqmask = ~getMask(&maskSet, x);
-        aExpr[i].prereqRight &= tqmask;
-        aExpr[i].prereqLeft &= tqmask;
-        aExpr[i].prereqAll &= tqmask;
+        int mask = ~getMask(&maskSet, x);
+        aExpr[i].prereqRight &= mask;
+        aExpr[i].prereqLeft &= mask;
+        aExpr[i].prereqAll &= mask;
       }
     }
   }
@@ -445,13 +445,13 @@ WhereInfo *sqliteWhereBegin(
   **
   ** Actually, if there are more than 32 tables in the join, only the
   ** first 32 tables are candidates for indices.  This is (again) due
-  ** to the limit of 32 bits in an integer bittqmask.
+  ** to the limit of 32 bits in an integer bitmask.
   */
   loopMask = 0;
   for(i=0; i<pTabList->nSrc && i<ARRAYSIZE(iDirectEq); i++){
     int j;
     int iCur = pTabList->a[i].iCursor;    /* The cursor for this table */
-    int tqmask = getMask(&maskSet, iCur);   /* Cursor tqmask for this table */
+    int mask = getMask(&maskSet, iCur);   /* Cursor mask for this table */
     Table *pTab = pTabList->a[i].pTab;
     Index *pIdx;
     Index *pBestIdx = 0;
@@ -493,7 +493,7 @@ WhereInfo *sqliteWhereBegin(
       }
     }
     if( iDirectEq[i]>=0 ){
-      loopMask |= tqmask;
+      loopMask |= mask;
       pWInfo->a[i].pIdx = 0;
       continue;
     }
@@ -620,7 +620,7 @@ WhereInfo *sqliteWhereBegin(
     pWInfo->a[i].pIdx = pBestIdx;
     pWInfo->a[i].score = bestScore;
     pWInfo->a[i].bRev = 0;
-    loopMask |= tqmask;
+    loopMask |= mask;
     if( pBestIdx ){
       pWInfo->a[i].iCur = pParse->nTab++;
       pWInfo->peakNTab = pParse->nTab;