Changeset: 6af3633de353 for MonetDB
URL: http://dev.monetdb.org/hg/MonetDB?cmd=changeset;node=6af3633de353
Modified Files:
        gdk/gdk_select.c
Branch: default
Log Message:

Cleanup, no real code changes.


diffs (truncated from 412 to 300 lines):

diff --git a/gdk/gdk_select.c b/gdk/gdk_select.c
--- a/gdk/gdk_select.c
+++ b/gdk/gdk_select.c
@@ -179,110 +179,157 @@ BAT_hashselect(BAT *b, BAT *s, BAT *bn, 
                }                                                       \
        } while (0)
 
-#define addresult(I) {\
-       if( cnt == lim ){ \
-               BATextend(bn, BATcount( b));\
-               lim = BATcapacity(bn); \
-               dst = (oid*) Tloc(bn, bn->U->first);\
-        } \
-       (dst)[cnt++] = I;\
-}
+#define LT(a, b)       ((a) < (b))
+#define LE(a, b)       ((a) <= (b))
+#define GT(a, b)       ((a) > (b))
+#define GE(a, b)       ((a) >= (b))
 
-#define SCANLOOPCAND5(TYPE,OP1,OP2,OP3,OP4)\
-       do { TYPE *src = (TYPE*) Tloc(b, b->U->first);\
-               oid *dst = (oid*) Tloc(bn, bn->U->first);\
-               BUN lim = BATcapacity(bn); \
-               BUN r;\
-               if (equi){\
-                       assert(li && hi);\
-                       assert(!anti);\
-                       for ((i) = (p); (i) < (q); (i)++){  \
-                               r = (BUN) (*candlist++ - off) ;\
-                               if ( (src)[r] == *(TYPE*) tl ) \
-                                       addresult(r);\
-                       }\
-               } else if (anti){\
-                       if ( nil == NULL) \
-                       for ((i) = (p); (i) < (q); (i)++) {\
-                               r = (BUN) (*candlist++ - off) ;\
-                               if ( ((lval && ( *(TYPE*) tl OP1 (src)[r])) ) 
||\
-                                     (hval && ( *(TYPE*) th OP2 (src)[r])) )\
-                                       addresult(r);\
-                       } else \
-                       for ((i) = (p); (i) < (q); (i)++) {\
-                               r = (BUN) (*candlist++ - off) ;\
-                               if ( ((lval && ( *(TYPE*) tl OP1 (src)[r]) ) ||\
-                                     (hval && ( *(TYPE*) th OP2 (src)[r]) )))\
-                                       if ( (src)[r] != TYPE##_nil) 
addresult(r); \
-                       }\
-               } else {\
-                       if ( nil == NULL) \
-                       for ((i) = (p); (i) < (q); (i)++) {\
-                               r = (BUN) (*candlist++ - off) ;\
-                               if ( (!lval || ( *(TYPE*) tl OP3 (src)[r] )) && 
\
-                                    (!hval || ( *(TYPE*) th OP4 (src)[r] )) ) \
-                                       addresult(r);\
-                       } else \
-                       for ((i) = (p); (i) < (q); (i)++) {\
-                               r = (BUN) (*candlist++ - off) ;\
-                               if ( (!lval || ( *(TYPE*) tl OP3 (src)[r] )) && 
\
-                                    (!hval || ( *(TYPE*) th OP4 (src)[r] )) ) \
-                                       if ( (src)[r] != TYPE##_nil) 
addresult(r); \
-                       }\
-               }\
-               BATsetcount(bn,cnt);\
-       } while (0);
+#define addresult(I)                                           \
+       do {                                                    \
+               if (cnt == lim) {                               \
+                       BATextend(bn, BATcount(b));             \
+                       lim = BATcapacity(bn);                  \
+                       dst = (oid*) Tloc(bn, bn->U->first);    \
+                }                                              \
+               dst[cnt++] = I;                                 \
+       } while (0)
 
-#define SCANLOOPCAND(TYPE) \
-       if ( li && hi ) { SCANLOOPCAND5(TYPE,>,<,<=,>=) } \
-       else if (li ) {SCANLOOPCAND5(TYPE,>,<=,<=,>) } \
-       else if (hi ) {SCANLOOPCAND5(TYPE,>=,<,<,>=) } \
-       else {SCANLOOPCAND5(TYPE,>=,<=,<,>) }
+#define SCANLOOPCAND5(TYPE, OP1, OP2)                                  \
+       do {                                                            \
+               TYPE *src = (TYPE *) Tloc(b, b->U->first);              \
+               oid *dst = (oid *) Tloc(bn, bn->U->first);              \
+               BUN lim = BATcapacity(bn);                              \
+               BUN r;                                                  \
+               if (equi) {                                             \
+                       assert(li && hi);                               \
+                       assert(!anti);                                  \
+                       for (i = p; i < q; i++) {                       \
+                               r = (BUN) (*candlist++ - off);          \
+                               if (src[r] == *(TYPE *) tl)             \
+                                       addresult(r);                   \
+                       }                                               \
+               } else if (anti) {                                      \
+                       if (nil == NULL) {                              \
+                               for (i = p; i < q; i++) {       \
+                                       r = (BUN) (*candlist++ - off) ; \
+                                       if ((lval &&                    \
+                                            OP1(*(TYPE *) tl, src[r])) || \
+                                           (hval &&                    \
+                                            OP2(*(TYPE *) th, src[r]))) \
+                                               addresult(r);           \
+                               }                                       \
+                       } else {                                        \
+                               for (i = p; i < q; i++) {       \
+                                       r = (BUN) (*candlist++ - off) ; \
+                                       if (((lval &&                   \
+                                             OP1(*(TYPE *) tl, src[r])) || \
+                                            (hval &&                   \
+                                             OP2(*(TYPE *) th, src[r]))) && \
+                                           src[r] != TYPE##_nil)       \
+                                               addresult(r);           \
+                               }                                       \
+                       }                                               \
+               } else {                                                \
+                       if (nil == NULL) {                              \
+                               for (i = p; i < q; i++) {               \
+                                       r = (BUN) (*candlist++ - off) ; \
+                                       if ((!lval ||                   \
+                                            !OP1(*(TYPE *) tl, src[r])) && \
+                                           (!hval ||                   \
+                                            !OP2(*(TYPE *) th, src[r]))) \
+                                               addresult(r);           \
+                               }                                       \
+                       } else {                                        \
+                               for (i = p; i < q; i++) {               \
+                                       r = (BUN) (*candlist++ - off) ; \
+                                       if ((!lval ||                   \
+                                            !OP1(*(TYPE *) tl, src[r])) && \
+                                           (!hval ||                   \
+                                            !OP2(*(TYPE *) th, src[r])) && \
+                                           src[r] != TYPE##_nil)       \
+                                               addresult(r);           \
+                               }                                       \
+                       }                                               \
+               }                                                       \
+               BATsetcount(bn,cnt);                                    \
+       } while (0)
 
+#define SCANLOOPCAND(TYPE)                             \
+       do {                                            \
+               if (li && hi)                           \
+                       SCANLOOPCAND5(TYPE, GT, LT);    \
+               else if (li)                            \
+                       SCANLOOPCAND5(TYPE, GT, LE);    \
+               else if (hi)                            \
+                       SCANLOOPCAND5(TYPE, GE, LT);    \
+               else                                    \
+                       SCANLOOPCAND5(TYPE, GE, LE);    \
+       } while (0)
 
-#define SCANLOOP5(TYPE,OP1,OP2,OP3,OP4)\
-       do { TYPE *src = (TYPE*) Tloc(b, b->U->first);\
-               oid *dst = (oid*) Tloc(bn, bn->U->first);\
-               BUN lim = BATcapacity(bn); \
-               if (equi){\
-                       assert(li && hi);\
-                       assert(!anti);\
-                       for ((i) = (p); (i) < (q); (i)++)  \
-                               if ( (src)[i] == *(TYPE*) tl ) \
-                                       addresult(i); \
-               } else if (anti){\
-                       if ( nil == NULL) \
-                       for ((i) = (p); (i) < (q); (i)++) {\
-                               if ( ((lval && ( *(TYPE*) tl OP1 (src)[i])) ) 
||\
-                                (hval && ( *(TYPE*) th OP2 (src)[i])) )\
-                                       addresult(i); \
-                       } else \
-                       for ((i) = (p); (i) < (q); (i)++) {\
-                               if ( ((lval && ( *(TYPE*) tl OP1 (src)[i]) ) ||\
-                                     (hval && ( *(TYPE*) th OP2 (src)[i]) )))\
-                                       if ( (src)[i] != TYPE##_nil) 
addresult(i); \
-                       }\
-               } else {\
-                       if ( nil == NULL) \
-                       for ((i) = (p); (i) < (q); (i)++) {\
-                               if ( (!lval || ( *(TYPE*) tl OP3 (src)[i] )) && 
\
-                                    (!hval || ( *(TYPE*) th OP4 (src)[i] )) ) \
-                                       addresult(i); \
-                       } else \
-                       for ((i) = (p); (i) < (q); (i)++) {\
-                               if ( (!lval || ( *(TYPE*) tl OP3 (src)[i] )) && 
\
-                                    (!hval || ( *(TYPE*) th OP4 (src)[i] )) ) \
-                                       if ( (src)[i] != TYPE##_nil) 
addresult(i); \
-                       }\
-               }\
-               BATsetcount(bn,cnt);\
-       } while (0);
+#define SCANLOOP5(TYPE, OP1, OP2)                                      \
+       do {                                                            \
+               TYPE *src = (TYPE *) Tloc(b, b->U->first);              \
+               oid *dst = (oid *) Tloc(bn, bn->U->first);              \
+               BUN lim = BATcapacity(bn);                              \
+               if (equi) {                                             \
+                       assert(li && hi);                               \
+                       assert(!anti);                                  \
+                       for (i = p; i < q; i++)                         \
+                               if (src[i] == *(TYPE *) tl)             \
+                                       addresult(i);                   \
+               } else if (anti) {                                      \
+                       if (nil == NULL) {                              \
+                               for (i = p; i < q; i++) {               \
+                                       if ((lval &&                    \
+                                            OP1(*(TYPE *) tl, src[i])) || \
+                                           (hval &&                    \
+                                            OP2(*(TYPE *) th, src[i]))) \
+                                               addresult(i);           \
+                               }                                       \
+                       } else {                                        \
+                               for (i = p; i < q; i++) {               \
+                                       if (((lval &&                   \
+                                             OP1(*(TYPE *) tl, src[i])) || \
+                                            (hval &&                   \
+                                             OP2(*(TYPE *) th, src[i]))) && \
+                                           src[i] != TYPE##_nil)       \
+                                               addresult(i);           \
+                               }                                       \
+                       }                                               \
+               } else {                                                \
+                       if (nil == NULL) {                              \
+                               for (i = p; i < q; i++) {               \
+                                       if ((!lval ||                   \
+                                            !OP1(*(TYPE *) tl, src[i])) && \
+                                           (!hval ||                   \
+                                            !OP2(*(TYPE *) th, src[i]))) \
+                                               addresult(i);           \
+                               }                                       \
+                       } else {                                        \
+                               for (i = p; i < q; i++) {               \
+                                       if ((!lval ||                   \
+                                            !OP1(*(TYPE *) tl, src[i])) && \
+                                           (!hval ||                   \
+                                            !OP2(*(TYPE *) th, src[i])) && \
+                                           src[i] != TYPE##_nil)       \
+                                               addresult(i);           \
+                               }                                       \
+                       }                                               \
+               }                                                       \
+               BATsetcount(bn,cnt);                                    \
+       } while (0)
 
-#define SCANLOOP(TYPE) \
-       if ( li && hi ) { SCANLOOP5(TYPE,>,<,<=,>=) } \
-       else if (li ) {SCANLOOP5(TYPE,>,<=,<=,>) } \
-       else if (hi ) {SCANLOOP5(TYPE,>=,<,<,>=) } \
-       else {SCANLOOP5(TYPE,>=,<=,<,>) }
+#define SCANLOOP(TYPE)                                 \
+       do {                                            \
+               if (li && hi)                           \
+                       SCANLOOP5(TYPE, GT, LT);        \
+               else if (li)                            \
+                       SCANLOOP5(TYPE, GT, LE);        \
+               else if (hi)                            \
+                       SCANLOOP5(TYPE, GE, LT);        \
+               else                                    \
+                       SCANLOOP5(TYPE, GE, LE);        \
+       } while (0)
 
 static BAT *
 BAT_scanselect(BAT *b, BAT *s, BAT *bn, const void *tl, const void *th,
@@ -325,34 +372,48 @@ BAT_scanselect(BAT *b, BAT *s, BAT *bn, 
                /* should we return an error if p > BUNfirst(s) || q <
                 * BUNlast(s) (i.e. s not fully used)? */
                candlist = (const oid *) Tloc(s, p);
-               switch(ATOMstorage(b->ttype) ){
-               case TYPE_bte: SCANLOOPCAND(bte); break;
-               case TYPE_sht: SCANLOOPCAND(sht); break;
-               case TYPE_int: SCANLOOPCAND(int); break;
-               case TYPE_flt: SCANLOOPCAND(flt); break;
-               case TYPE_dbl: SCANLOOPCAND(dbl); break;
-               case TYPE_lng: SCANLOOPCAND(lng); break;
-               default: 
+               switch (ATOMstorage(b->ttype)) {
+               case TYPE_bte:
+                       SCANLOOPCAND(bte);
+                       break;
+               case TYPE_sht:
+                       SCANLOOPCAND(sht);
+                       break;
+               case TYPE_int:
+                       SCANLOOPCAND(int);
+                       break;
+               case TYPE_flt:
+                       SCANLOOPCAND(flt);
+                       break;
+               case TYPE_dbl:
+                       SCANLOOPCAND(dbl);
+                       break;
+               case TYPE_lng:
+                       SCANLOOPCAND(lng);
+                       break;
+               default:
                        if (equi) {
                                assert(li && hi);
                                assert(!anti);
                                candscanloop((*cmp)(tl, v) == 0);
                        } else if (anti) {
-                               candscanloop((nil == NULL || (*cmp)(v, nil) != 
0) &&
-                                                ((lval &&
-                                                  ((c = (*cmp)(tl, v)) > 0 ||
_______________________________________________
checkin-list mailing list
checkin-list@monetdb.org
http://mail.monetdb.org/mailman/listinfo/checkin-list

Reply via email to