Changeset: 01a980817a19 for MonetDB
URL: https://dev.monetdb.org/hg/MonetDB/rev/01a980817a19
Modified Files:
        gdk/gdk_aggr.c
        gdk/gdk_analytic_func.c
        gdk/gdk_imprints.c
        gdk/gdk_private.h
        gdk/gdk_project.c
        gdk/gdk_select.c
        gdk/gdk_string.c
        gdk/gdk_subquery.c
        gdk/gdk_system.h
        gdk/gdk_tracer.h
Branch: Jul2021
Log Message:

Backslash alignment.


diffs (truncated from 5330 to 300 lines):

diff --git a/gdk/gdk_aggr.c b/gdk/gdk_aggr.c
--- a/gdk/gdk_aggr.c
+++ b/gdk/gdk_aggr.c
@@ -2901,7 +2901,7 @@ BATgroupavg3combine(BAT *avg, BAT *rem, 
                        } else {                                        \
                                sum = -sum;                             \
                                a = - (TYPE) (sum / n); /* this fits */ \
-                               r = (lng) (sum % n);            \
+                               r = (lng) (sum % n);                    \
                                if (r) {                                \
                                        a--;                            \
                                        r = n - r;                      \
@@ -3008,7 +3008,7 @@ BATcalcavg(BAT *b, BAT *s, dbl *avg, BUN
 
 #define AGGR_COUNT(TYPE)                                               \
        do {                                                            \
-               const TYPE *restrict vals = (const TYPE *) bi.base; \
+               const TYPE *restrict vals = (const TYPE *) bi.base;     \
                while (ncand > 0) {                                     \
                        ncand--;                                        \
                        i = canditer_next(&ci) - b->hseqbase;           \
@@ -3244,7 +3244,7 @@ BATgroupsize(BAT *b, BAT *g, BAT *e, BAT
 
 #define AGGR_CMP(TYPE, OP)                                             \
        do {                                                            \
-               const TYPE *restrict vals = (const TYPE *) bi.base; \
+               const TYPE *restrict vals = (const TYPE *) bi.base;     \
                if (ngrp == ncand) {                                    \
                        /* single element groups */                     \
                        while (ncand > 0) {                             \
@@ -4337,8 +4337,8 @@ BATcalcvariance_sample(dbl *avgp, BAT *b
                        delta2 = (dbl) y - mean2;                       \
                        mean2 += delta2 / n;                            \
                        m2 += delta1 * ((dbl) y - mean2);               \
-                       if (isinf(m2))                  \
-                               goto overflow;          \
+                       if (isinf(m2))                                  \
+                               goto overflow;                          \
                }                                                       \
        } while (0)
 
@@ -4431,8 +4431,8 @@ BATcalccovariance_sample(BAT *b1, BAT *b
                        up += delta1 * aux;                             \
                        down1 += delta1 * ((dbl) x - mean1);            \
                        down2 += delta2 * aux;                          \
-                       if (isinf(up) || isinf(down1) || isinf(down2))          
\
-                               goto overflow;          \
+                       if (isinf(up) || isinf(down1) || isinf(down2))  \
+                               goto overflow;                          \
                }                                                       \
        } while (0)
 
@@ -4785,8 +4785,8 @@ BATgroupvariance_population(BAT *b, BAT 
                        } else if (cnts[i] == 1) {                      \
                                dbls[i] = issample ? dbl_nil : 0;       \
                                nils2++;                                \
-                       } else if (isinf(m2[i])) {              \
-                               goto overflow;          \
+                       } else if (isinf(m2[i])) {                      \
+                               goto overflow;                          \
                        } else {                                        \
                                dbls[i] = m2[i] / (cnts[i] - issample); \
                        }                                               \
@@ -4989,8 +4989,8 @@ BATgroupcovariance_population(BAT *b1, B
                        if (cnts[i] <= 1 || cnts[i] == BUN_NONE || down1[i] == 
0 || down2[i] == 0) { \
                                dbls[i] = dbl_nil;                      \
                                nils++;                                 \
-                       } else if (isinf(up[i]) || isinf(down1[i]) || 
isinf(down2[i])) {        \
-                               goto overflow;          \
+                       } else if (isinf(up[i]) || isinf(down1[i]) || 
isinf(down2[i])) { \
+                               goto overflow;                          \
                        } else {                                        \
                                dbls[i] = (up[i] / cnts[i]) / (sqrt(down1[i] / 
cnts[i]) * sqrt(down2[i] / cnts[i])); \
                                assert(!is_dbl_nil(dbls[i]));           \
diff --git a/gdk/gdk_analytic_func.c b/gdk/gdk_analytic_func.c
--- a/gdk/gdk_analytic_func.c
+++ b/gdk/gdk_analytic_func.c
@@ -43,61 +43,61 @@ GDKrebuild_segment_tree(oid ncount, oid 
 }
 
 #define NTILE_CALC(TPE, NEXT_VALUE, LNG_HGE, UPCAST, VALIDATION)       \
-       do {                                    \
-               UPCAST j = 0, ncnt = (UPCAST) (i - k); \
-               for (; k < i; k++, j++) {       \
-                       TPE val = NEXT_VALUE; \
-                       if (is_##TPE##_nil(val)) {      \
-                               has_nils = true;        \
-                               rb[k] = TPE##_nil;      \
-                       } else { \
-                               UPCAST nval = (UPCAST) LNG_HGE; \
-                               VALIDATION /* validation must come after null 
check */  \
-                               if (nval >= ncnt) { \
-                                       rb[k] = (TPE)(j + 1);  \
-                               } else { \
-                                       UPCAST bsize = ncnt / nval; \
+       do {                                                            \
+               UPCAST j = 0, ncnt = (UPCAST) (i - k);                  \
+               for (; k < i; k++, j++) {                               \
+                       TPE val = NEXT_VALUE;                           \
+                       if (is_##TPE##_nil(val)) {                      \
+                               has_nils = true;                        \
+                               rb[k] = TPE##_nil;                      \
+                       } else {                                        \
+                               UPCAST nval = (UPCAST) LNG_HGE;         \
+                               VALIDATION /* validation must come after null 
check */ \
+                               if (nval >= ncnt) {                     \
+                                       rb[k] = (TPE)(j + 1);           \
+                               } else {                                \
+                                       UPCAST bsize = ncnt / nval;     \
                                        UPCAST top = ncnt - nval * bsize; \
                                        UPCAST small = top * (bsize + 1); \
-                                       if ((UPCAST) j < small) \
+                                       if ((UPCAST) j < small)         \
                                                rb[k] = (TPE)(1 + j / (bsize + 
1)); \
-                                       else \
+                                       else                            \
                                                rb[k] = (TPE)(1 + top + (j - 
small) / bsize); \
-                               } \
-                       } \
-               } \
+                               }                                       \
+                       }                                               \
+               }                                                       \
        } while (0)
 
-#define ANALYTICAL_NTILE(IMP, TPE, NEXT_VALUE, LNG_HGE, UPCAST, VALIDATION)    
\
-       do {                                                    \
-               TPE *restrict rb = (TPE*)Tloc(r, 0);            \
+#define ANALYTICAL_NTILE(IMP, TPE, NEXT_VALUE, LNG_HGE, UPCAST, VALIDATION) \
+       do {                                                            \
+               TPE *restrict rb = (TPE*)Tloc(r, 0);                    \
                if (p) {                                                \
-                       while (i < cnt) {                       \
-                               if (np[i])      {               \
-ntile##IMP##TPE: \
+                       while (i < cnt) {                               \
+                               if (np[i])      {                       \
+ntile##IMP##TPE:                                                       \
                                        NTILE_CALC(TPE, NEXT_VALUE, LNG_HGE, 
UPCAST, VALIDATION); \
-                               } \
-                               if (!last) \
-                                       i++; \
-                       }                               \
-               }                               \
-               if (!last) { \
-                       last = true; \
-                       i = cnt; \
-                       goto ntile##IMP##TPE; \
-               } \
+                               }                                       \
+                               if (!last)                              \
+                                       i++;                            \
+                       }                                               \
+               }                                                       \
+               if (!last) {                                            \
+                       last = true;                                    \
+                       i = cnt;                                        \
+                       goto ntile##IMP##TPE;                           \
+               }                                                       \
        } while (0)
 
-#define ANALYTICAL_NTILE_SINGLE_IMP(TPE, LNG_HGE, UPCAST) \
-       do {    \
-               TPE ntl = *(TPE*) ntile; \
+#define ANALYTICAL_NTILE_SINGLE_IMP(TPE, LNG_HGE, UPCAST)              \
+       do {                                                            \
+               TPE ntl = *(TPE*) ntile;                                \
                if (!is_##TPE##_nil(ntl) && ntl <= 0) goto invalidntile; \
                ANALYTICAL_NTILE(SINGLE, TPE, ntl, LNG_HGE, UPCAST, ;); \
        } while (0)
 
-#define ANALYTICAL_NTILE_MULTI_IMP(TPE, LNG_HGE, UPCAST) \
-       do {    \
-               const TPE *restrict nn = (TPE*)ni.base; \
+#define ANALYTICAL_NTILE_MULTI_IMP(TPE, LNG_HGE, UPCAST)               \
+       do {                                                            \
+               const TPE *restrict nn = (TPE*)ni.base;                 \
                ANALYTICAL_NTILE(MULTI, TPE, nn[k], LNG_HGE, UPCAST, if (val <= 
0) goto invalidntile;); \
        } while (0)
 
@@ -194,16 +194,16 @@ invalidntile:
        return GDK_FAIL;
 }
 
-#define ANALYTICAL_FIRST_FIXED(TPE)                            \
-       do {                                                    \
-               const TPE *bp = (TPE*)bi.base;                  \
-               TPE *restrict rb = (TPE*)Tloc(r, 0);            \
-               for (; k < cnt; k++) { \
+#define ANALYTICAL_FIRST_FIXED(TPE)                                    \
+       do {                                                            \
+               const TPE *bp = (TPE*)bi.base;                          \
+               TPE *restrict rb = (TPE*)Tloc(r, 0);                    \
+               for (; k < cnt; k++) {                                  \
                        const TPE *bs = bp + start[k], *be = bp + end[k]; \
                        TPE curval = (be > bs) ? *bs : TPE##_nil;       \
-                       rb[k] = curval;                         \
+                       rb[k] = curval;                                 \
                        has_nils |= is_##TPE##_nil(curval);             \
-               }                                               \
+               }                                                       \
        } while (0)
 
 gdk_return
@@ -276,16 +276,16 @@ GDKanalyticalfirst(BAT *r, BAT *b, BAT *
        return GDK_SUCCEED;
 }
 
-#define ANALYTICAL_LAST_FIXED(TPE)                             \
-       do {                                                    \
-               const TPE *bp = (TPE*)bi.base;                  \
-               TPE *restrict rb = (TPE*)Tloc(r, 0);            \
-               for (; k < cnt; k++) { \
+#define ANALYTICAL_LAST_FIXED(TPE)                                     \
+       do {                                                            \
+               const TPE *bp = (TPE*)bi.base;                          \
+               TPE *restrict rb = (TPE*)Tloc(r, 0);                    \
+               for (; k < cnt; k++) {                                  \
                        const TPE *bs = bp + start[k], *be = bp + end[k]; \
                        TPE curval = (be > bs) ? *(be - 1) : TPE##_nil; \
-                       rb[k] = curval;                         \
+                       rb[k] = curval;                                 \
                        has_nils |= is_##TPE##_nil(curval);             \
-               }                                               \
+               }                                                       \
        } while (0)
 
 gdk_return
@@ -363,7 +363,7 @@ GDKanalyticallast(BAT *r, BAT *b, BAT *s
                TPE *restrict rb = (TPE*)Tloc(r, 0);                    \
                if (is_lng_nil(nth)) {                                  \
                        has_nils = true;                                \
-                       for (; k < cnt; k++)                    \
+                       for (; k < cnt; k++)                            \
                                rb[k] = TPE##_nil;                      \
                } else {                                                \
                        nth--;                                          \
@@ -385,15 +385,15 @@ GDKanalyticallast(BAT *r, BAT *b, BAT *s
                        lng lnth = tp[k];                               \
                        const TPE *bs = bp + start[k];                  \
                        const TPE *be = bp + end[k];                    \
-                       if (!is_lng_nil(lnth) && lnth <= 0) goto invalidnth;    
\
+                       if (!is_lng_nil(lnth) && lnth <= 0) goto invalidnth; \
                        if (is_lng_nil(lnth) || be <= bs || lnth - 1 > 
(lng)(end[k] - start[k])) { \
-                               curval = TPE##_nil;     \
-                               has_nils = true;        \
-                       } else {                                                
\
+                               curval = TPE##_nil;                     \
+                               has_nils = true;                        \
+                       } else {                                        \
                                curval = *(bs + lnth - 1);              \
                                has_nils |= is_##TPE##_nil(curval);     \
-                       }       \
-                       rb[k] = curval; \
+                       }                                               \
+                       rb[k] = curval;                                 \
                }                                                       \
        } while (0)
 
@@ -589,7 +589,7 @@ invalidnth:
                for (; rb < rp; rb++, bp++) {                   \
                        next = *bp;                             \
                        *rb = next;                             \
-                       has_nils |= is_##TPE##_nil(next);               \
+                       has_nils |= is_##TPE##_nil(next);       \
                }                                               \
        } while (0)
 
@@ -723,22 +723,22 @@ GDKanalyticallag(BAT *r, BAT *b, BAT *p,
        return GDK_SUCCEED;
 }
 
-#define LEAD_CALC(TPE)                                         \
-       do {                                                    \
-               if (lead < ncnt) {                              \
-                       bp += lead;                             \
-                       l = ncnt - lead;                        \
-                       for (i = 0; i < l; i++, rb++, bp++) {   \
-                               next = *bp;                     \
-                               *rb = next;                     \
+#define LEAD_CALC(TPE)                                                 \
+       do {                                                            \
+               if (lead < ncnt) {                                      \
+                       bp += lead;                                     \
+                       l = ncnt - lead;                                \
+                       for (i = 0; i < l; i++, rb++, bp++) {           \
+                               next = *bp;                             \
+                               *rb = next;                             \
                                has_nils |= is_##TPE##_nil(next);       \
-                       }                                       \
-               } else {                                        \
-                       bp += ncnt;                             \
-               }                                               \
-               for (;rb < rp; rb++)                            \
-                       *rb = def;                              \
-               has_nils |= (lead > 0 && is_##TPE##_nil(def));  \
+                       }                                               \
+               } else {                                                \
+                       bp += ncnt;                                     \
+               }                                                       \
_______________________________________________
checkin-list mailing list
checkin-list@monetdb.org
https://www.monetdb.org/mailman/listinfo/checkin-list

Reply via email to