Changeset: 1851882d7ba6 for MonetDB
URL: https://dev.monetdb.org/hg/MonetDB/rev/1851882d7ba6
Modified Files:
        gdk/gdk_analytic_bounds.c
        gdk/gdk_analytic_func.c
        gdk/gdk_string.c
        monetdb5/extras/rapi/rapi.c
        monetdb5/modules/atoms/json.c
        monetdb5/modules/mal/mkey.c
        sql/backends/monet5/UDF/pyapi3/conversion3.c
        sql/backends/monet5/UDF/pyapi3/emit3.c
Branch: default
Log Message:

I don't like `break' after closing braces.
In fact, the only keywords allowed after a closing brace (i.e. on the
same line) are `else' and `while' if it belongs to a `do'.


diffs (truncated from 401 to 300 lines):

diff --git a/gdk/gdk_analytic_bounds.c b/gdk/gdk_analytic_bounds.c
--- a/gdk/gdk_analytic_bounds.c
+++ b/gdk/gdk_analytic_bounds.c
@@ -116,20 +116,20 @@ GDKanalyticaldiff(BAT *r, BAT *b, BAT *p
                ANALYTICAL_DIFF_IMP(hge);
                break;
 #endif
-       case TYPE_flt: {
+       case TYPE_flt:
                if (bi.nonil) {
                        ANALYTICAL_DIFF_IMP(flt);
                } else { /* Because of NaN values, use this path */
                        ANALYTICAL_DIFF_FLOAT_IMP(flt);
                }
-       } break;
-       case TYPE_dbl: {
+               break;
+       case TYPE_dbl:
                if (bi.nonil) {
                        ANALYTICAL_DIFF_IMP(dbl);
                } else { /* Because of NaN values, use this path */
                        ANALYTICAL_DIFF_FLOAT_IMP(dbl);
                }
-       } break;
+               break;
        default:{
                const void *v = BUNtail(bi, 0), *next;
                int (*atomcmp) (const void *, const void *) = ATOMcompare(tpe);
@@ -714,57 +714,57 @@ GDKanalyticalpeers(BAT *r, BAT *b, BAT *
        bool last = false;
 
        switch (ATOMbasetype(bi.type)) {
-       case TYPE_bte: {
+       case TYPE_bte:
                if (preceding) {
                        ANALYTICAL_WINDOW_BOUNDS_BRANCHES_PEERS(_PRECEDING, 
bte, NO_NAN_CHECK);
                } else {
                        ANALYTICAL_WINDOW_BOUNDS_BRANCHES_PEERS(_FOLLOWING, 
bte, NO_NAN_CHECK);
                }
-       } break;
-       case TYPE_sht: {
+               break;
+       case TYPE_sht:
                if (preceding) {
                        ANALYTICAL_WINDOW_BOUNDS_BRANCHES_PEERS(_PRECEDING, 
sht, NO_NAN_CHECK);
                } else {
                        ANALYTICAL_WINDOW_BOUNDS_BRANCHES_PEERS(_FOLLOWING, 
sht, NO_NAN_CHECK);
                }
-       } break;
-       case TYPE_int: {
+               break;
+       case TYPE_int:
                if (preceding) {
                        ANALYTICAL_WINDOW_BOUNDS_BRANCHES_PEERS(_PRECEDING, 
int, NO_NAN_CHECK);
                } else {
                        ANALYTICAL_WINDOW_BOUNDS_BRANCHES_PEERS(_FOLLOWING, 
int, NO_NAN_CHECK);
                }
-       } break;
-       case TYPE_lng: {
+               break;
+       case TYPE_lng:
                if (preceding) {
                        ANALYTICAL_WINDOW_BOUNDS_BRANCHES_PEERS(_PRECEDING, 
lng, NO_NAN_CHECK);
                } else {
                        ANALYTICAL_WINDOW_BOUNDS_BRANCHES_PEERS(_FOLLOWING, 
lng, NO_NAN_CHECK);
                }
-       } break;
+               break;
 #ifdef HAVE_HGE
-       case TYPE_hge: {
+       case TYPE_hge:
                if (preceding) {
                        ANALYTICAL_WINDOW_BOUNDS_BRANCHES_PEERS(_PRECEDING, 
hge, NO_NAN_CHECK);
                } else {
                        ANALYTICAL_WINDOW_BOUNDS_BRANCHES_PEERS(_FOLLOWING, 
hge, NO_NAN_CHECK);
                }
-       } break;
+               break;
 #endif
-       case TYPE_flt: {
+       case TYPE_flt:
                if (preceding) {
                        ANALYTICAL_WINDOW_BOUNDS_BRANCHES_PEERS(_PRECEDING, 
flt, && (!is_flt_nil(next) || !is_flt_nil(prev)));
                } else {
                        ANALYTICAL_WINDOW_BOUNDS_BRANCHES_PEERS(_FOLLOWING, 
flt, && (!is_flt_nil(next) || !is_flt_nil(prev)));
                }
-       } break;
-       case TYPE_dbl: {
+               break;
+       case TYPE_dbl:
                if (preceding) {
                        ANALYTICAL_WINDOW_BOUNDS_BRANCHES_PEERS(_PRECEDING, 
dbl, && (!is_dbl_nil(next) || !is_dbl_nil(prev)));
                } else {
                        ANALYTICAL_WINDOW_BOUNDS_BRANCHES_PEERS(_FOLLOWING, 
dbl, && (!is_dbl_nil(next) || !is_dbl_nil(prev)));
                }
-       } break;
+               break;
        default: {
                const void *prev, *next;
                int (*atomcmp) (const void *, const void *) = 
ATOMcompare(bi.type);
@@ -941,7 +941,8 @@ GDKanalyticalrowbounds(BAT *r, BAT *b, B
 #else
                        limit = (lng) (*(lng *) bound);
 #endif
-               } break;
+                       break;
+               }
 #ifdef HAVE_HGE
                case TYPE_hge: {
                        hge nval = *(hge *) bound;
@@ -1386,7 +1387,8 @@ GDKanalyticalgroupsbounds(BAT *r, BAT *b
 #else
                        limit = (lng) (*(lng *) bound);
 #endif
-               } break;
+                       break;
+               }
 #ifdef HAVE_HGE
                case TYPE_hge: {
                        hge nval = *(hge *) bound;
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
@@ -1280,25 +1280,25 @@ GDKanalytical##OP(BAT *r, BAT *p, BAT *o
                                                                        \
        if (cnt > 0) {                                                  \
                switch (frame_type) {                                   \
-               case 3: /* unbounded until current row */       {       \
+               case 3: /* unbounded until current row */               \
                        ANALYTICAL_MIN_MAX_BRANCHES(MIN_MAX, GT_LT, 
UNBOUNDED_TILL_CURRENT_ROW); \
-               } break;                                                \
-               case 4: /* current row until unbounded */       {       \
+                       break;                                          \
+               case 4: /* current row until unbounded */               \
                        ANALYTICAL_MIN_MAX_BRANCHES(MIN_MAX, GT_LT, 
CURRENT_ROW_TILL_UNBOUNDED); \
-               } break;                                                \
-               case 5: /* all rows */  {                               \
+                       break;                                          \
+               case 5: /* all rows */                                  \
                        ANALYTICAL_MIN_MAX_BRANCHES(MIN_MAX, GT_LT, ALL_ROWS); \
-               } break;                                                \
-               case 6: /* current row */ {                             \
+                       break;                                          \
+               case 6: /* current row */                               \
                        ANALYTICAL_MIN_MAX_BRANCHES(MIN_MAX, GT_LT, 
CURRENT_ROW); \
-               } break;                                                \
-               default: {                                              \
+                       break;                                          \
+               default:                                                \
                        if (!(st = GDKinitialize_segment_tree())) {     \
                                res = GDK_FAIL;                         \
                                goto cleanup;                           \
                        }                                               \
                        ANALYTICAL_MIN_MAX_BRANCHES(MIN_MAX, GT_LT, OTHERS); \
-               }                                                       \
+                       break;                                          \
                }                                                       \
        }                                                               \
                                                                        \
@@ -1640,25 +1640,25 @@ GDKanalyticalcount(BAT *r, BAT *p, BAT *
 
        if (cnt > 0) {
                switch (frame_type) {
-               case 3: /* unbounded until current row */       {
+               case 3: /* unbounded until current row */
                        ANALYTICAL_COUNT_BRANCHES(UNBOUNDED_TILL_CURRENT_ROW);
-               } break;
-               case 4: /* current row until unbounded */       {
+                       break;
+               case 4: /* current row until unbounded */
                        ANALYTICAL_COUNT_BRANCHES(CURRENT_ROW_TILL_UNBOUNDED);
-               } break;
-               case 5: /* all rows */  {
+                       break;
+               case 5: /* all rows */
                        ANALYTICAL_COUNT_BRANCHES(ALL_ROWS);
-               } break;
-               case 6: /* current row */ {
+                       break;
+               case 6: /* current row */
                        ANALYTICAL_COUNT_BRANCHES(CURRENT_ROW);
-               } break;
-               default: {
+                       break;
+               default:
                        if (!count_all && !(st = GDKinitialize_segment_tree())) 
{
                                res = GDK_FAIL;
                                goto cleanup;
                        }
                        ANALYTICAL_COUNT_BRANCHES(OTHERS);
-               }
+                       break;
                }
        }
 
@@ -1968,25 +1968,25 @@ GDKanalyticalsum(BAT *r, BAT *p, BAT *o,
 
        if (cnt > 0) {
                switch (frame_type) {
-               case 3: /* unbounded until current row */       {
+               case 3: /* unbounded until current row */
                        ANALYTICAL_SUM_BRANCHES(UNBOUNDED_TILL_CURRENT_ROW);
-               } break;
-               case 4: /* current row until unbounded */       {
+                       break;
+               case 4: /* current row until unbounded */
                        ANALYTICAL_SUM_BRANCHES(CURRENT_ROW_TILL_UNBOUNDED);
-               } break;
-               case 5: /* all rows */  {
+                       break;
+               case 5: /* all rows */
                        ANALYTICAL_SUM_BRANCHES(ALL_ROWS);
-               } break;
-               case 6: /* current row */ {
+                       break;
+               case 6: /* current row */
                        ANALYTICAL_SUM_BRANCHES(CURRENT_ROW);
-               } break;
-               default: {
+                       break;
+               default:
                        if (!(st = GDKinitialize_segment_tree())) {
                                res = GDK_FAIL;
                                goto cleanup;
                        }
                        ANALYTICAL_SUM_BRANCHES(OTHERS);
-               }
+                       break;
                }
        }
 
@@ -2487,25 +2487,25 @@ GDKanalyticalprod(BAT *r, BAT *p, BAT *o
 
        if (cnt > 0) {
                switch (frame_type) {
-               case 3: /* unbounded until current row */       {
+               case 3: /* unbounded until current row */
                        ANALYTICAL_PROD_BRANCHES(UNBOUNDED_TILL_CURRENT_ROW);
-               } break;
-               case 4: /* current row until unbounded */       {
+                       break;
+               case 4: /* current row until unbounded */
                        ANALYTICAL_PROD_BRANCHES(CURRENT_ROW_TILL_UNBOUNDED);
-               } break;
-               case 5: /* all rows */  {
+                       break;
+               case 5: /* all rows */
                        ANALYTICAL_PROD_BRANCHES(ALL_ROWS);
-               } break;
-               case 6: /* current row */ {
+                       break;
+               case 6: /* current row */
                        ANALYTICAL_PROD_BRANCHES(CURRENT_ROW);
-               } break;
-               default: {
+                       break;
+               default:
                        if (!(st = GDKinitialize_segment_tree())) {
                                res = GDK_FAIL;
                                goto cleanup;
                        }
                        ANALYTICAL_PROD_BRANCHES(OTHERS);
-               }
+                       break;
                }
        }
 
diff --git a/gdk/gdk_string.c b/gdk/gdk_string.c
--- a/gdk/gdk_string.c
+++ b/gdk/gdk_string.c
@@ -1402,20 +1402,20 @@ GDKanalytical_str_group_concat(BAT *r, B
 
        if (cnt > 0) {
                switch (frame_type) {
-               case 3: /* unbounded until current row */       {
+               case 3: /* unbounded until current row */
                        
ANALYTICAL_STR_GROUP_CONCAT_PARTITIONS(ANALYTICAL_STR_GROUP_CONCAT_UNBOUNDED_TILL_CURRENT_ROW);
-               } break;
+                       break;
                case 4: /* current row until unbounded */
                        goto notimplemented;
-               case 5: /* all rows */  {
+               case 5: /* all rows */
                        
ANALYTICAL_STR_GROUP_CONCAT_PARTITIONS(ANALYTICAL_STR_GROUP_CONCAT_ALL_ROWS);
-               } break;
-               case 6: /* current row */ {
+                       break;
+               case 6: /* current row */
                        
ANALYTICAL_STR_GROUP_CONCAT_PARTITIONS(ANALYTICAL_STR_GROUP_CONCAT_CURRENT_ROW);
-               } break;
-               default: {
+                       break;
+               default:
                        
ANALYTICAL_STR_GROUP_CONCAT_PARTITIONS(ANALYTICAL_STR_GROUP_CONCAT_OTHERS);
-               }
+                       break;
                }
        }
 
diff --git a/monetdb5/extras/rapi/rapi.c b/monetdb5/extras/rapi/rapi.c
_______________________________________________
checkin-list mailing list -- [email protected]
To unsubscribe send an email to [email protected]

Reply via email to