Changeset: a962575ffeef for MonetDB
URL: http://dev.monetdb.org/hg/MonetDB?cmd=changeset;node=a962575ffeef
Modified Files:
        gdk/gdk_calc.c
        gdk/gdk_calc_compare.h
Branch: default
Log Message:

Merge with Jul2015 branch.


diffs (140 lines):

diff --git a/gdk/gdk_calc.c b/gdk/gdk_calc.c
--- a/gdk/gdk_calc.c
+++ b/gdk/gdk_calc.c
@@ -124,14 +124,16 @@ checkbats(BAT *b1, BAT *b2, const char *
                CANDLOOP((TYPE3 *) dst, k, TYPE3##_nil, 0, start);      \
                for (i = start * incr1, j = start * incr2, k = start;   \
                     k < end; i += incr1, j += incr2, k++) {            \
+                       register TYPE1 v1;                              \
+                       register TYPE2 v2;                              \
                        CHECKCAND((TYPE3 *) dst, k, candoff, TYPE3##_nil); \
-                       if (((const TYPE1 *) lft)[i] == TYPE1##_nil ||  \
-                           ((const TYPE2 *) rgt)[j] == TYPE2##_nil) {  \
+                       v1 = ((const TYPE1 *) lft)[i];                  \
+                       v2 = ((const TYPE2 *) rgt)[j];                  \
+                       if (v1 == TYPE1##_nil || v2 == TYPE2##_nil) {   \
                                nils++;                                 \
                                ((TYPE3 *) dst)[k] = TYPE3##_nil;       \
                        } else {                                        \
-                               ((TYPE3 *) dst)[k] = FUNC(((const TYPE1 *) 
lft)[i], \
-                                                         ((const TYPE2 *) 
rgt)[j]); \
+                               ((TYPE3 *) dst)[k] = FUNC(v1, v2);      \
                        }                                               \
                }                                                       \
                CANDLOOP((TYPE3 *) dst, k, TYPE3##_nil, end, cnt);      \
@@ -141,9 +143,14 @@ checkbats(BAT *b1, BAT *b2, const char *
        do {                                                            \
                CANDLOOP((TYPE3 *) dst, k, TYPE3##_nil, 0, start);      \
                for (i = start * incr1, j = start * incr2, k = start;   \
-                    k < end; i += incr1, j += incr2, k++)              \
-                       ((TYPE3 *) dst)[k] = FUNC(((const TYPE1 *) lft)[i], \
-                                                 ((const TYPE2 *) rgt)[j]); \
+                    k < end; i += incr1, j += incr2, k++) {            \
+                       register TYPE1 v1;                              \
+                       register TYPE2 v2;                              \
+                       CHECKCAND((TYPE3 *) dst, k, candoff, TYPE3##_nil); \
+                       v1 = ((const TYPE1 *) lft)[i];                  \
+                       v2 = ((const TYPE2 *) rgt)[j];                  \
+                       ((TYPE3 *) dst)[k] = FUNC(v1, v2);              \
+               }                                                       \
                CANDLOOP((TYPE3 *) dst, k, TYPE3##_nil, end, cnt);      \
        } while (0)
 
@@ -152,26 +159,27 @@ checkbats(BAT *b1, BAT *b2, const char *
                CANDLOOP((TYPE3 *) dst, k, TYPE3##_nil, 0, start);      \
                for (i = start * incr1, j = start * incr2, k = start;   \
                     k < end; i += incr1, j += incr2, k++) {            \
+                       register TYPE1 v1;                              \
+                       register TYPE2 v2;                              \
                        CHECKCAND((TYPE3 *) dst, k, candoff, TYPE3##_nil); \
-                       if (((const TYPE1 *) lft)[i] == TYPE1##_nil ||  \
-                           ((const TYPE2 *) rgt)[j] == TYPE2##_nil) {  \
+                       v1 = ((const TYPE1 *) lft)[i];                  \
+                       v2 = ((const TYPE2 *) rgt)[j];                  \
+                       if (v1 == TYPE1##_nil || v2 == TYPE2##_nil) {   \
                                nils++;                                 \
                                ((TYPE3 *) dst)[k] = TYPE3##_nil;       \
-                       } else if (CHECK(((const TYPE1 *) lft)[i],      \
-                                        ((const TYPE2 *) rgt)[j])) {   \
+                       } else if (CHECK(v1, v2)) {                     \
                                if (abort_on_error) {                   \
                                        GDKerror("%s: shift operand too large 
in " \
                                                 
#FUNC"("FMT##TYPE1","FMT##TYPE2").\n", \
                                                 func,                  \
-                                                CST##TYPE1 ((const TYPE1 *) 
lft)[i], \
-                                                CST##TYPE2 ((const TYPE2 *) 
rgt)[j]); \
+                                                CST##TYPE1 v1,         \
+                                                CST##TYPE2 v2);        \
                                        goto checkfail;                 \
                                }                                       \
                                ((TYPE3 *)dst)[k] = TYPE3##_nil;        \
                                nils++;                                 \
                        } else {                                        \
-                               ((TYPE3 *) dst)[k] = FUNC(((const TYPE1 *) 
lft)[i], \
-                                                         ((const TYPE2 *) 
rgt)[j]); \
+                               ((TYPE3 *) dst)[k] = FUNC(v1, v2);      \
                        }                                               \
                }                                                       \
                CANDLOOP((TYPE3 *) dst, k, TYPE3##_nil, end, cnt);      \
@@ -12589,7 +12597,8 @@ VARcalcrsh(ValPtr ret, const ValRecord *
 /* ---------------------------------------------------------------------- */
 /* generic comparison (any "linear" type) */
 
-#define CMP(a, b)      ((bte) ((a) < (b) ? -1 : (a) > (b)))
+/* #define CMP(a, b)   ((bte) ((a) < (b) ? -1 : (a) > (b))) */
+#define CMP(a, b)      ((bte) (((a) > (b)) - ((a) < (b))))
 
 #define TYPE_TPE               TYPE_bte
 #define TPE                    bte
diff --git a/gdk/gdk_calc_compare.h b/gdk/gdk_calc_compare.h
--- a/gdk/gdk_calc_compare.h
+++ b/gdk/gdk_calc_compare.h
@@ -650,10 +650,10 @@ BATcalcop(BAT *b1, BAT *b2, BAT *s)
                return bn;
        }
 
-       bn = BATcalcop_intern(b1->T->type == TYPE_void ? (void *) &b1->T->seq : 
(void *) Tloc(b1, b1->batFirst), b1->T->type, 1,
+       bn = BATcalcop_intern(b1->T->type == TYPE_void ? (void *) &b1->T->seq : 
(void *) Tloc(b1, b1->batFirst), ATOMbasetype(b1->T->type), 1,
                              b1->T->vheap ? b1->T->vheap->base : NULL,
                              b1->T->width,
-                             b2->T->type == TYPE_void ? (void *) &b2->T->seq : 
(void *) Tloc(b2, b2->batFirst), b2->T->type, 1,
+                             b2->T->type == TYPE_void ? (void *) &b2->T->seq : 
(void *) Tloc(b2, b2->batFirst), ATOMbasetype(b2->T->type), 1,
                              b2->T->vheap ? b2->T->vheap->base : NULL,
                              b2->T->width,
                              cnt, start, end, cand, candend, b1->hseqbase,
@@ -677,10 +677,10 @@ BATcalcopcst(BAT *b, const ValRecord *v,
 
        CANDINIT(b, s, start, end, cnt, cand, candend);
 
-       bn = BATcalcop_intern(Tloc(b, b->batFirst), b->T->type, 1,
+       bn = BATcalcop_intern(Tloc(b, b->batFirst), ATOMbasetype(b->T->type), 1,
                              b->T->vheap ? b->T->vheap->base : NULL,
                              b->T->width,
-                             VALptr(v), v->vtype, 0,
+                             VALptr(v), ATOMbasetype(v->vtype), 0,
                              NULL, 0,
                              cnt, start, end, cand, candend, b->hseqbase,
                              cand == NULL && b->T->nonil && ATOMcmp(v->vtype, 
VALptr(v), ATOMnilptr(v->vtype)) != 0,
@@ -703,9 +703,9 @@ BATcalccstop(const ValRecord *v, BAT *b,
 
        CANDINIT(b, s, start, end, cnt, cand, candend);
 
-       bn = BATcalcop_intern(VALptr(v), v->vtype, 0,
+       bn = BATcalcop_intern(VALptr(v), ATOMbasetype(v->vtype), 0,
                              NULL, 0,
-                             Tloc(b, b->batFirst), b->T->type, 1,
+                             Tloc(b, b->batFirst), ATOMbasetype(b->T->type), 1,
                              b->T->vheap ? b->T->vheap->base : NULL,
                              b->T->width,
                              cnt, start, end, cand, candend, b->hseqbase,
@@ -719,8 +719,8 @@ gdk_return
 VARcalcop(ValPtr ret, const ValRecord *lft, const ValRecord *rgt)
 {
        ret->vtype = TYPE_TPE;
-       if (op_typeswitchloop(VALptr(lft), lft->vtype, 0, NULL, 0,
-                             VALptr(rgt), rgt->vtype, 0, NULL, 0,
+       if (op_typeswitchloop(VALptr(lft), ATOMbasetype(lft->vtype), 0, NULL, 0,
+                             VALptr(rgt), ATOMbasetype(rgt->vtype), 0, NULL, 0,
                              VALget(ret), 1, 0, 1, NULL, NULL, 0, 0,
                              VARcalcop_name) == BUN_NONE)
                return GDK_FAIL;
_______________________________________________
checkin-list mailing list
checkin-list@monetdb.org
https://www.monetdb.org/mailman/listinfo/checkin-list

Reply via email to