Get rid of icc warnings (with port-win warnings.) Addresss #1185.

git-svn-id: file:///svn/tokudb.1131b+1080a+1185+nostatementexprs@6466 c7de825b-a66e-492c-adef-691d508d4ae1

newbrt/Makefile

@@ -40,14 +40,16 @@ VISIBILITY=-fvisibility=hidden
  endif
 endif
 
-CFLAGS =  -Werror -Wall $(FORMAT) $(OPTFLAGS) $(GCOV_FLAGS) $(PROF_FLAGS) $(FPICFLAGS) $(SHADOW) $(VISIBILITY)
+CFLAGS = -Werror -Wall $(FORMAT) $(OPTFLAGS) $(GCOV_FLAGS) $(PROF_FLAGS) $(FPICFLAGS) $(SHADOW) $(VISIBILITY)
 ifneq ($(CC),icc)
 CFLAGS += -Wextra -Wcast-align -Wbad-function-cast -Wmissing-noreturn -g3 -ggdb3
 else
 CFLAGS += -g
+ CFLAGS += -diag-enable port-win
  CFLAGS += -diag-disable  177     # Don't complain about static variables that are not used.
  #CFLAGS += -diag-disable  188     # Don't complain about enumerated type mixed with another type.
  CFLAGS += -diag-disable  589     # Don't complain about goto into a block that skips initializing variables.  GCC catches the actual uninitialized variables.
+ CFLAGS += -diag-disable  869    # Don't complain about unused variables (since we defined __attribute__ to be nothing.)
  CFLAGS += -diag-disable  981    # Don't complain about "operands are evaluated in unspecified order".  This seems to be generated whenever more than one argument to a function or operand is computed by function call.
  CFLAGS += -diag-disable 1324    # Don't complain about rdtsc clobbering its registers more than once.
 endif
@@ -151,7 +153,7 @@ check-fanout:
 
 BRT_INTERNAL_H_INCLUDES = brt-internal.h cachetable.h fifo.h omt.h brt.h brt-search.h brttypes.h ybt.h log.h ../include/db.h kv-pair.h memory.h mempool.h leafentry.h
 brt-test-helpers.o: $(BRT_INTERNAL_H_INCLUDES) toku_assert.h
-logformat: logformat.c toku_assert.c
+logformat: logformat.c
 brt-serialize-test.o: $(BRT_INTERNAL_H_INCLUDES)
 
 test_toku_malloc_plain_free: newbrt.o

newbrt/brt-serialize.c

@@ -237,14 +237,14 @@ void toku_serialize_brtnode_to (int fd, BLOCKNUM blocknum, BRTNODE node, struct
 		//printf("%s:%d p%d=%p n_entries=%d\n", __FILE__, __LINE__, i, node->mdicts[i], mdict_n_entries(node->mdicts[i]));
 		wbuf_int(&w, toku_fifo_n_entries(BNC_BUFFER(node,i)));
 		FIFO_ITERATE(BNC_BUFFER(node,i), key, keylen, data, datalen, type, xid,
-				  ({
+				  {
 				      assert(type>=0 && type<256);
 				      wbuf_char(&w, (unsigned char)type);
 				      wbuf_TXNID(&w, xid);
 				      wbuf_bytes(&w, key, keylen);
 				      wbuf_bytes(&w, data, datalen);
 				      check_local_fingerprint+=node->rand4fingerprint*toku_calc_fingerprint_cmd(type, xid, key, keylen, data, datalen);
-				  }));
+				  });
 	    }
 	    //printf("%s:%d check_local_fingerprint=%8x\n", __FILE__, __LINE__, check_local_fingerprint);
 	    if (check_local_fingerprint!=node->local_fingerprint) printf("%s:%d node=%" PRId64 " fingerprint expected=%08x actual=%08x\n", __FILE__, __LINE__, node->thisnodename.b, check_local_fingerprint, node->local_fingerprint);
@@ -882,7 +882,7 @@ int toku_serialize_fifo_at (int fd, off_t freeoff, FIFO fifo) {
 	freeoff+=size;
     }
     FIFO_ITERATE(fifo, key, keylen, val, vallen, type, xid,
-		 ({
+		 {
 		     size_t size=keylen+vallen+1+8+4+4;
 		     char  *MALLOC_N(size, buf);
 		     assert(buf!=0);
@@ -903,7 +903,7 @@ int toku_serialize_fifo_at (int fd, off_t freeoff, FIFO fifo) {
 		     assert(r==(ssize_t)size);
 		     freeoff+=size;
 		     toku_free(buf);
-		 }));
+		 });
     unlock_for_pwrite();
     return 0;
 }

newbrt/brt-verify.c

@@ -23,9 +23,9 @@ static void verify_local_fingerprint (BRTNODE node) {
     if (node->height>0) {
 	for (i=0; i<node->u.n.n_children; i++)
 	    FIFO_ITERATE(BNC_BUFFER(node,i), key, keylen, data, datalen, type, xid,
-			      ({
+			      {
 				  fp += node->rand4fingerprint * toku_calc_fingerprint_cmd(type, xid, key, keylen, data, datalen);
-			      }));
+			      });
 	assert(fp==node->local_fingerprint);
     } else {
 	toku_verify_counts(node);

newbrt/brt.c

@@ -884,7 +884,7 @@ static int handle_split_of_child (BRT t, BRTNODE node, int childnum,
 
     // Remove all the cmds from the local fingerprint.  Some may get added in again when we try to push to the child.
     FIFO_ITERATE(old_h, skey, skeylen, sval, svallen, type, xid,
-		 ({
+		 {
 		     u_int32_t old_fingerprint   = node->local_fingerprint;
 		     u_int32_t new_fingerprint   = old_fingerprint - node->rand4fingerprint*toku_calc_fingerprint_cmd(type, xid, skey, skeylen, sval, svallen);
 		     if (t->txn_that_created != xid) {
@@ -892,7 +892,7 @@ static int handle_split_of_child (BRT t, BRTNODE node, int childnum,
 			 assert(r==0);
 		     }
 		     node->local_fingerprint = new_fingerprint;
-		 }));
+		 });
 
     //verify_local_fingerprint_nonleaf(node);
 
@@ -923,12 +923,11 @@ static int handle_split_of_child (BRT t, BRTNODE node, int childnum,
 
     node->u.n.n_bytes_in_buffers -= old_count; /* By default, they are all removed.  We might add them back in. */
     /* Keep pushing to the children, but not if the children would require a pushdown */
-    FIFO_ITERATE(old_h, skey, skeylen, sval, svallen, type, xid, ({
-        DBT skd, svd;
-        BRT_CMD_S brtcmd = { (enum brt_cmd_type)type, xid, .u.id= {toku_fill_dbt(&skd, skey, skeylen),
-						toku_fill_dbt(&svd, sval, svallen)} };
+    FIFO_ITERATE(old_h, skey, skeylen, sval, svallen, type, xid, {
+	DBT skd; DBT svd;
+        BRT_CMD_S brtcmd = build_brt_cmd((enum brt_cmd_type)type, xid, toku_fill_dbt(&skd, skey, skeylen), toku_fill_dbt(&svd, sval, svallen));
 	//verify_local_fingerprint_nonleaf(childa); 	verify_local_fingerprint_nonleaf(childb);
-	int pusha = 0, pushb = 0;
+	int pusha = 0; int pushb = 0;
 	switch (type) {
 	case BRT_INSERT:
 	case BRT_DELETE_BOTH:
@@ -980,7 +979,7 @@ static int handle_split_of_child (BRT t, BRTNODE node, int childnum,
 	printf("Bad type %d\n", type); // Don't use default: because I want a compiler warning if I forget a enum case, and I want a runtime error if the type isn't one of the expected ones.
 	assert(0);
      ok: /*nothing*/;
-		     }));
+		     });
 
     toku_fifo_free(&old_h);
 
@@ -1928,9 +1927,8 @@ static void verify_local_fingerprint_nonleaf (BRTNODE node) {
     if (node->height==0) return;
     for (i=0; i<node->u.n.n_children; i++)
 	FIFO_ITERATE(BNC_BUFFER(node,i), key, keylen, data, datalen, type, xid,
-			  ({
-			      fp += node->rand4fingerprint * toku_calc_fingerprint_cmd(type, xid, key, keylen, data, datalen);
-			  }));
+		     fp += node->rand4fingerprint * toku_calc_fingerprint_cmd(type, xid, key, keylen, data, datalen);
+		     );
     assert(fp==node->local_fingerprint);
 }
 
@@ -2697,12 +2695,12 @@ toku_dump_brtnode (BRT brt, BLOCKNUM blocknum, int depth, bytevec lorange, ITEML
 	    for (i=0; i< node->u.n.n_children; i++) {
 		printf("%*schild %d buffered (%d entries):\n", depth+1, "", i, toku_fifo_n_entries(BNC_BUFFER(node,i)));
 		FIFO_ITERATE(BNC_BUFFER(node,i), key, keylen, data, datalen, type, xid,
-				  ({
+				  {
 				      data=data; datalen=datalen; keylen=keylen;
 				      printf("%*s xid=%"PRIu64" %u (type=%d)\n", depth+2, "", xid, ntohl(*(int*)key), type);
 				      //assert(strlen((char*)key)+1==keylen);
 				      //assert(strlen((char*)data)+1==datalen);
-				  }));
+				  });
 	    }
 	    for (i=0; i<node->u.n.n_children; i++) {
 		printf("%*schild %d\n", depth, "", i);

newbrt/brtdump.c

@@ -49,7 +49,7 @@ dump_header (int f, struct brt_header **header) {
     printf(" fifo has %d entries\n", toku_fifo_n_entries(h->fifo));
     if (dump_data) {
 	FIFO_ITERATE(h->fifo, key, keylen, data, datalen, type, xid,
-		     ({
+		     {
 			 printf(" ");
 			 switch (type) {
 			 case BRT_NONE: printf("NONE"); goto ok;
@@ -68,7 +68,7 @@ dump_header (int f, struct brt_header **header) {
 			 printf(" ");
 			 print_item(data, datalen);
 			 printf("\n");
-		     }));
+		     });
     }
 }
 
@@ -130,7 +130,7 @@ dump_node (int f, BLOCKNUM blocknum, struct brt_header *h) {
 	    printf("   buffer contains %u bytes (%d items)\n", BNC_NBYTESINBUF(n, i), toku_fifo_n_entries(BNC_BUFFER(n,i)));
 	    if (dump_data) {
 		FIFO_ITERATE(BNC_BUFFER(n,i), key, keylen, data, datalen, typ, xid,
-			     ({
+			     {
 				 printf("    TYPE=");
 				 switch ((enum brt_cmd_type)typ) {
 				 case BRT_NONE: printf("NONE"); goto ok;
@@ -151,7 +151,7 @@ dump_node (int f, BLOCKNUM blocknum, struct brt_header *h) {
 				     print_item(data, datalen);
 				 }
 				 printf("\n");
-			     })
+			     }
 			     );
 	    }
 	}

newbrt/brttypes.h

@@ -101,6 +101,13 @@ struct brt_cmd {
 };
 typedef struct brt_cmd BRT_CMD_S, *BRT_CMD;
 
+static inline
+BRT_CMD_S
+build_brt_cmd (enum brt_cmd_type type, TXNID xid, DBT *key, DBT *val) {
+    BRT_CMD_S result = {type, xid, .u.id={key,val}};
+    return result;
+}
+
 #define UU(x) x __attribute__((__unused__))
 
 typedef struct leafentry *LEAFENTRY;

newbrt/fifo.h

@@ -28,7 +28,7 @@ unsigned long toku_fifo_memory_size(FIFO); // return how much memory the fifo us
 //int toku_fifo_peek_deq_cmdstruct (FIFO, BRT_CMD, DBT*, DBT*); // fill in the BRT_CMD, using the two DBTs for the DBT part.
 void toku_fifo_iterate (FIFO, void(*f)(bytevec key,ITEMLEN keylen,bytevec data,ITEMLEN datalen,int type, TXNID xid, void*), void*);
 
-#define FIFO_ITERATE(fifo,keyvar,keylenvar,datavar,datalenvar,typevar,xidvar,body) ({      \
+#define FIFO_ITERATE(fifo,keyvar,keylenvar,datavar,datalenvar,typevar,xidvar,body) do {    \
   int fifo_iterate_off;                                                                    \
   for (fifo_iterate_off = toku_fifo_iterate_internal_start(fifo);                          \
        toku_fifo_iterate_internal_has_more(fifo, fifo_iterate_off);			   \
@@ -41,7 +41,7 @@ void toku_fifo_iterate (FIFO, void(*f)(bytevec key,ITEMLEN keylen,bytevec data,I
       int     typevar = e->type;                                                      \
       TXNID   xidvar = e->xid;                                                        \
       body;                                                                           \
-  } })
+  } } while (0)
 
 // Internal functions for the iterator.
 int toku_fifo_iterate_internal_start(FIFO fifo);

newbrt/fingerprint.c

 /* -*- mode: C; c-basic-offset: 4 -*- */
 #ident "Copyright (c) 2007, 2008 Tokutek Inc.  All rights reserved."
 
-#include <arpa/inet.h>
-#include "brt-internal.h"
-#include "toku_assert.h"
-#include "x1764.h"
+#include "includes.h"
 
 // Calculate the fingerprint for a kvpair
 static void toku_calc_more_murmur_kvpair (struct x1764 *mm, const void *key, int keylen, const void *val, int vallen) {

newbrt/includes.h

@@ -6,7 +6,9 @@
 #endif
 #define _FILE_OFFSET_BITS 64
 
-#include <arpa/inet.h>
+// Portability first!
+#include "portability.h"
+
 #include <ctype.h>
 #include <dirent.h>
 #include <errno.h>

newbrt/leafentry.h

@@ -27,10 +27,9 @@
  * The case of a committed pair and a provisional pair can be represented by a committed pair, since it doesn't matter whether the transction aborts or commits, the value is the same.
  */
 
-#include "brttypes.h"
+#include "portability.h"
 #include "rbuf.h"
 #include "x1764.h"
-#include <arpa/inet.h>
 
 u_int32_t toku_le_crc(LEAFENTRY v);
 
@@ -80,7 +79,7 @@ static inline u_int64_t getint64 (unsigned char *p) {
     return (H<<32) + L;
 }
 
-#define LESWITCHCALL(le,funname, ...) ({	                                                                     \
+#define LESWITCHCALL(le,funname, ...) do {	                                                                     \
   switch(get_le_state(le)) {					                                                     \
   case LE_COMMITTED: {                                                                                               \
     unsigned char* __klenaddr = 1+(unsigned char*)le;  u_int32_t __klen = getint(__klenaddr);                        \
@@ -111,7 +110,7 @@ static inline u_int64_t getint64 (unsigned char *p) {
     unsigned char* __plenaddr = __klen + __kvaladdr;   u_int32_t __plen = getint(__plenaddr);                        \
     unsigned char* __pvaladdr = 4 + __plenaddr;                                                                      \
     return funname ## _le_provpair(__xid, __klen, __kvaladdr, __plen, __pvaladdr, ## __VA_ARGS__); }                 \
-  } abort(); })
+  } abort(); } while (0)
 
 
 u_int32_t leafentry_memsize (LEAFENTRY le); // the size of a leafentry in memory.

newbrt/log.h

@@ -16,10 +16,10 @@ struct logbytes {
     struct logbytes *next;
     int nbytes;
     LSN lsn;
-    char bytes[0];
+    char bytes[1];
 };
 
-#define MALLOC_LOGBYTES(n) toku_malloc(sizeof(struct logbytes)+n)
+#define MALLOC_LOGBYTES(n) toku_malloc(sizeof(struct logbytes)+n -1)
 
 int toku_logger_create(TOKULOGGER */*resultp*/);
 void toku_logger_set_cachetable (TOKULOGGER, CACHETABLE);

newbrt/logformat.c

@@ -9,7 +9,7 @@
  *   The struct definitions.
  *   The Latex documentation.
  */
-#include "toku_assert.h"
+#include <assert.h>
 #include <ctype.h>
 #include <stdarg.h>
 #include <stdio.h>
@@ -206,11 +206,11 @@ const struct logtype logtypes[] = {
 };
 
   
-#define DO_STRUCTS(lt, array, body) ({ \
+#define DO_STRUCTS(lt, array, body) do {	\
     const struct logtype *lt;    \
     for (lt=&array[0]; lt->name; lt++) {	\
 	body; \
-    } })
+    } } while (0)
 
 #define DO_ROLLBACKS(lt, body) DO_STRUCTS(lt, rollbacks, body)
 
@@ -218,11 +218,11 @@ const struct logtype logtypes[] = {
 
 #define DO_LOGTYPES_AND_ROLLBACKS(lt, body) (DO_ROLLBACKS(lt,body), DO_LOGTYPES(lt, body))
 
-#define DO_FIELDS(fld, lt, body) ({ \
+#define DO_FIELDS(fld, lt, body) do { \
     struct field *fld; \
     for (fld=lt->fields; fld->type; fld++) { \
         body; \
-    } })
+    } } while (0)
 
 
 static void __attribute__((format (printf, 3, 4))) fprintf2 (FILE *f1, FILE *f2, const char *format, ...) {
@@ -245,7 +245,7 @@ generate_enum_internal (char *enum_name, char *enum_prefix, const struct logtype
     memset(used_cmds, 0, 256);
     fprintf(hf, "enum %s {", enum_name);
     DO_STRUCTS(lt, lts,
-		({
+		{
 		    unsigned char cmd = (unsigned char)(lt->command_and_flags&0xff);
 		    if (count!=0) fprintf(hf, ",");
 		    count++;
@@ -253,7 +253,7 @@ generate_enum_internal (char *enum_name, char *enum_prefix, const struct logtype
 		    fprintf(hf,"    %s_%-16s = '%c'", enum_prefix, lt->name, cmd);
 		    if (used_cmds[cmd]!=0) { fprintf(stderr, "%s:%d: error: Command %d (%c) was used twice (second time for %s)\n", __FILE__, __LINE__, cmd, cmd, lt->name); abort(); }
 		    used_cmds[cmd]=1;
-		}));
+		});
     fprintf(hf, "\n};\n\n");
    
 }
@@ -267,7 +267,7 @@ generate_enum (void) {
 static void
 generate_log_struct (void) {
     DO_LOGTYPES(lt,
-		({  fprintf(hf, "struct logtype_%s {\n", lt->name);
+		{  fprintf(hf, "struct logtype_%s {\n", lt->name);
 		    fprintf(hf, "  %-16s lsn;\n", "LSN");
 		    DO_FIELDS(ft, lt,
 			      fprintf(hf, "  %-16s %s;\n", ft->type, ft->name));
@@ -277,9 +277,9 @@ generate_log_struct (void) {
 		    //fprintf(hf, "void toku_recover_%s (LSN lsn", lt->name);
 		    //DO_FIELDS(ft, lt, fprintf(hf, ", %s %s", ft->type, ft->name));
 		    //fprintf(hf, ");\n");
-		}));
+		});
     DO_ROLLBACKS(lt,
-		 ({  fprintf(hf, "struct rolltype_%s {\n", lt->name);
+		 {  fprintf(hf, "struct rolltype_%s {\n", lt->name);
 		     DO_FIELDS(ft, lt,
 			       fprintf(hf, "  %-16s %s;\n", ft->type, ft->name));
 		     fprintf(hf, "};\n");
@@ -289,7 +289,7 @@ generate_log_struct (void) {
 		     fprintf(hf, "int toku_commit_%s (", lt->name);
 		     DO_FIELDS(ft, lt, fprintf(hf, "%s %s,", ft->type, ft->name));
 		     fprintf(hf, "TOKUTXN txn);\n");
-		 }));
+		 });
     fprintf(hf, "struct log_entry {\n");
     fprintf(hf, "  enum lt_cmd cmd;\n");
     fprintf(hf, "  union {\n");
@@ -314,37 +314,37 @@ generate_dispatch (void) {
     DO_ROLLBACKS(lt, fprintf(hf, "  case RT_%s: funprefix ## %s (&(s)->u.%s); break;\\\n", lt->name, lt->name, lt->name));
     fprintf(hf, " }})\n");
 
-    fprintf(hf, "#define logtype_dispatch_assign(s, funprefix, var, args...) ({ switch((s)->cmd) {\\\n");
+    fprintf(hf, "#define logtype_dispatch_assign(s, funprefix, var, args...) do { switch((s)->cmd) {\\\n");
     DO_LOGTYPES(lt, fprintf(hf, "  case LT_%s: var = funprefix ## %s (&(s)->u.%s, ## args); break;\\\n", lt->name, lt->name, lt->name));
-    fprintf(hf, " }})\n");
+    fprintf(hf, " }} while (0)\n");
 
-    fprintf(hf, "#define rolltype_dispatch_assign(s, funprefix, var, args...) ({ \\\n");
+    fprintf(hf, "#define rolltype_dispatch_assign(s, funprefix, var, args...) do { \\\n");
     fprintf(hf, "  switch((s)->cmd) {\\\n");
-    DO_ROLLBACKS(lt, ({
+    DO_ROLLBACKS(lt, {
 		    fprintf(hf, "  case RT_%s: var = funprefix ## %s (", lt->name, lt->name);
 		    int fieldcount=0;
-		    DO_FIELDS(ft, lt, ({
+		    DO_FIELDS(ft, lt, {
 				if (fieldcount>0) fprintf(hf, ",");
 				fprintf(hf, "(s)->u.%s.%s", lt->name, ft->name);
 				fieldcount++;
-			    }));
+			    });
 		    fprintf(hf, ",## args); break;\\\n");
-		}));
-    fprintf(hf, "  default: assert(0);} })\n");
+		});
+    fprintf(hf, "  default: assert(0);} } while (0)\n");
 
-    fprintf(hf, "#define logtype_dispatch_args(s, funprefix) ({ switch((s)->cmd) {\\\n");
+    fprintf(hf, "#define logtype_dispatch_args(s, funprefix) do { switch((s)->cmd) {\\\n");
     DO_LOGTYPES(lt,
-		({
+		{
 		    fprintf(hf, "  case LT_%s: funprefix ## %s ((s)->u.%s.lsn", lt->name, lt->name, lt->name);
 		    DO_FIELDS(ft, lt, fprintf(hf, ",(s)->u.%s.%s", lt->name, ft->name));
 		    fprintf(hf, "); break;\\\n");
-		}));
-    fprintf(hf, " }})\n");
+		});
+    fprintf(hf, " }} while (0)\n");
 }
 		
 static void
 generate_log_writer (void) {
-    DO_LOGTYPES(lt, ({
+    DO_LOGTYPES(lt, {
 			fprintf2(cf, hf, "int toku_log_%s (TOKULOGGER logger, LSN *lsnp, int do_fsync", lt->name);
 			DO_FIELDS(ft, lt, fprintf2(cf, hf, ", %s %s", ft->type, ft->name));
 			fprintf(hf, ");\n");
@@ -375,12 +375,12 @@ generate_log_writer (void) {
 			fprintf(cf, "  assert(wbuf.ndone==buflen);\n");
 			fprintf(cf, "  return r;\n");
 			fprintf(cf, "}\n\n");
-		    }));
+		    });
 }
 
 static void
 generate_log_reader (void) {
-    DO_LOGTYPES(lt, ({
+    DO_LOGTYPES(lt, {
 			fprintf(cf, "static int toku_log_fread_%s (FILE *infile, struct logtype_%s *data, struct x1764 *checksum)", lt->name, lt->name);
 			fprintf(cf, " {\n");
 			fprintf(cf, "  int r=0;\n");
@@ -394,7 +394,7 @@ generate_log_reader (void) {
 			fprintf(cf, "  if (checksum_in_file!=x1764_finish(checksum) || len_in_file!=actual_len) return DB_BADFORMAT;\n");
 			fprintf(cf, "  return 0;\n");
 			fprintf(cf, "}\n\n");
-		    }));
+		    });
     fprintf2(cf, hf, "int toku_log_fread (FILE *infile, struct log_entry *le)");
     fprintf(hf, ";\n");
     fprintf(cf, " {\n");
@@ -409,10 +409,10 @@ generate_log_reader (void) {
     fprintf(cf, "  x1764_add(&checksum, &cmdchar, 1);\n");
     fprintf(cf, "  le->cmd=(enum lt_cmd)cmd;\n");
     fprintf(cf, "  switch ((enum lt_cmd)cmd) {\n");
-    DO_LOGTYPES(lt, ({
+    DO_LOGTYPES(lt, {
 			fprintf(cf, "  case LT_%s:\n", lt->name);
 			fprintf(cf, "    return toku_log_fread_%s (infile, &le->u.%s, &checksum);\n", lt->name, lt->name);
-		    }));
+		    });
     fprintf(cf, "  };\n");
     fprintf(cf, "  return DB_BADFORMAT;\n"); // Should read past the record using the len field.
     fprintf(cf, "}\n\n");
@@ -437,8 +437,8 @@ generate_logprint (void) {
     fprintf(cf, "    char charcmd = (char)cmd;\n");
     fprintf(cf, "    x1764_add(&checksum, &charcmd, 1);\n");
     fprintf(cf, "    switch ((enum lt_cmd)cmd) {\n");
-    DO_LOGTYPES(lt, ({ if (strlen(lt->name)>maxnamelen) maxnamelen=strlen(lt->name); }));
-    DO_LOGTYPES(lt, ({
+    DO_LOGTYPES(lt, { if (strlen(lt->name)>maxnamelen) maxnamelen=strlen(lt->name); });
+    DO_LOGTYPES(lt, {
 		unsigned char cmd = (unsigned char)(0xff&lt->command_and_flags);
 		fprintf(cf, "    case LT_%s: \n", lt->name);
 		// We aren't using the log reader here because we want better diagnostics as soon as things go wrong.
@@ -446,12 +446,12 @@ generate_logprint (void) {
 		if (isprint(cmd)) fprintf(cf,"        fprintf(outf, \" '%c':\");\n", cmd);
 		else                      fprintf(cf,"        fprintf(outf, \"0%03o:\");\n", cmd);
 		fprintf(cf, "        r = toku_logprint_%-16s(outf, f, \"lsn\", &checksum, &len, 0);     if (r!=0) return r;\n", "LSN");
-		DO_FIELDS(ft, lt, ({
+		DO_FIELDS(ft, lt, {
 			    fprintf(cf, "        r = toku_logprint_%-16s(outf, f, \"%s\", &checksum, &len,", ft->type, ft->name);
 			    if (ft->format) fprintf(cf, "\"%s\"", ft->format);
 			    else            fprintf(cf, "0");
 			    fprintf(cf, "); if (r!=0) return r;\n");
-			}));
+			});
 		fprintf(cf, "        {\n");
 		fprintf(cf, "          u_int32_t actual_murmur = x1764_finish(&checksum);\n");
 		fprintf(cf, "          r = toku_fread_u_int32_t_nocrclen (f, &crc_in_file); len+=4; if (r!=0) return r;\n");
@@ -464,7 +464,7 @@ generate_logprint (void) {
 		fprintf(cf, "        };\n");
 		fprintf(cf, "        fprintf(outf, \"\\n\");\n");
 		fprintf(cf, "        return 0;;\n\n");
-	    }));
+	    });
     fprintf(cf, "    }\n");
     fprintf(cf, "    fprintf(outf, \"Unknown command %%d ('%%c')\", cmd, cmd);\n");
     fprintf(cf, "    return DB_BADFORMAT;\n");
@@ -473,7 +473,7 @@ generate_logprint (void) {
 
 static void
 generate_rollbacks (void) {
-    DO_ROLLBACKS(lt, ({
+    DO_ROLLBACKS(lt, {
 		    fprintf2(cf, hf, "int toku_logger_save_rollback_%s (TOKUTXN txn", lt->name);
 		    DO_FIELDS(ft, lt, fprintf2(cf, hf, ", %s %s", ft->type, ft->name));
 		    fprintf(hf, ");\n");
@@ -495,9 +495,9 @@ generate_rollbacks (void) {
 		    fprintf(cf, "  txn->newest_logentry = v;\n");
 		    fprintf(cf, "  txn->rollentry_resident_bytecount += rollback_fsize;\n");
 		    fprintf(cf, "  return toku_maybe_spill_rollbacks(txn);\n}\n");
-	    }));
+	    });
 
-    DO_ROLLBACKS(lt, ({
+    DO_ROLLBACKS(lt, {
 		fprintf2(cf, hf, "void toku_logger_rollback_wbufwrite_%s (struct wbuf *wbuf", lt->name);
 		DO_FIELDS(ft, lt, fprintf2(cf, hf, ", %s %s", ft->type, ft->name));
 		fprintf2(cf, hf, ")");
@@ -508,18 +508,18 @@ generate_rollbacks (void) {
 		DO_FIELDS(ft, lt, fprintf(cf, "  wbuf_%s(wbuf, %s);\n", ft->type, ft->name));
 		fprintf(cf, "  wbuf_int(wbuf, 4+wbuf->ndone - ndone_at_start);\n");
 		fprintf(cf, "}\n");
-	    }));
+	    });
     fprintf2(cf, hf, "void toku_logger_rollback_wbufwrite (struct wbuf *wbuf, struct roll_entry *r)");
     fprintf(hf, ";\n");
     fprintf(cf, " {\n  switch (r->cmd) {\n");
-    DO_ROLLBACKS(lt, ({
+    DO_ROLLBACKS(lt, {
 		fprintf(cf, "    case RT_%s: toku_logger_rollback_wbufwrite_%s(wbuf", lt->name, lt->name);
 		DO_FIELDS(ft, lt, fprintf(cf, ", r->u.%s.%s", lt->name, ft->name));
 		fprintf(cf, "); return;\n");
-	    }));
+	    });
     fprintf(cf, "  }\n  assert(0);\n");
     fprintf(cf, "}\n");
-    DO_ROLLBACKS(lt, ({
+    DO_ROLLBACKS(lt, {
 		fprintf2(cf, hf, "u_int32_t toku_logger_rollback_fsize_%s (", lt->name);
 		int count=0;
 		DO_FIELDS(ft, lt, fprintf2(cf, hf, "%s%s %s", (count++>0)?", ":"", ft->type, ft->name));
@@ -530,16 +530,16 @@ generate_rollbacks (void) {
 		DO_FIELDS(ft, lt, 
 			  fprintf(cf, "\n         + toku_logsizeof_%s(%s)", ft->type, ft->name));
 		fprintf(cf, ";\n}\n");
-	    }));
+	    });
     fprintf2(cf, hf, "u_int32_t toku_logger_rollback_fsize(struct roll_entry *item)");
     fprintf(hf, ";\n");
     fprintf(cf, "{\n  switch(item->cmd) {\n");
-    DO_ROLLBACKS(lt, ({
+    DO_ROLLBACKS(lt, {
 		fprintf(cf, "    case RT_%s: return toku_logger_rollback_fsize_%s(", lt->name, lt->name);
 		int count=0;
 		DO_FIELDS(ft, lt, fprintf(cf, "%sitem->u.%s.%s", (count++>0)?", ":"", lt->name, ft->name));
 		fprintf(cf, ");\n");
-	    }));
+	    });
     fprintf(cf, "  }\n  assert(0);\n  return 0;\n");
     fprintf(cf, "}\n");
 
@@ -548,12 +548,12 @@ generate_rollbacks (void) {
     fprintf(cf, " {\n  assert(n_bytes>0);\n  struct roll_entry *item = malloc_in_memarena(ma, sizeof(*item));\n  item->cmd=(enum rt_cmd)(buf[0]);\n");
     fprintf(cf, "  struct rbuf rc = {buf, n_bytes, 1};\n");
     fprintf(cf, "  switch(item->cmd) {\n");
-    DO_ROLLBACKS(lt, ({
+    DO_ROLLBACKS(lt, {
 		fprintf(cf, "  case RT_%s:\n", lt->name);
 		DO_FIELDS(ft, lt, fprintf(cf, "  rbuf_ma_%s(&rc, ma, &item->u.%s.%s);\n", ft->type, lt->name, ft->name));
 		fprintf(cf, "    *itemp = item;\n");
 		fprintf(cf, "    return 0;\n");
-	    }));
+	});
     fprintf(cf, "  }\n  return EINVAL;\n}\n");
 }
 

newbrt/portability.h

+#ifndef PORTABILITY_H
+#define PORTABILITY_H
+
+// Portability layer
+
+
+#if defined(__ICC)
+
+// Intel compiler.
+//  Define ntohl using bswap.
+//  Define __attribute__ to be null
+
+#include <sys/types.h>
+
+static inline
+u_int32_t
+ntohl(u_int32_t x) {
+    return _bswap(x);
+}
+static inline
+u_int32_t
+htonl(u_int32_t x) {
+    return _bswap(x);
+}
+
+#define __attribute__(x)
+
+#elif defined __GNUC__
+
+// Gcc:
+//   Define ntohl using arpa/inet.h
+#include <arpa/inet.h>
+#else
+#error Not ICC and not GNUC.  What compiler?
+#endif
+
+
+#endif

newbrt/rbuf.h

@@ -3,10 +3,11 @@
 
 #ident "Copyright (c) 2007 Tokutek Inc.  All rights reserved."
 
+#include "portability.h"
+#include "memarena.h"
 #include "toku_assert.h"
+#include "brttypes.h"
 #include "memory.h"
-#include "memarena.h"
-#include <arpa/inet.h>
 
 struct rbuf {
     unsigned char *buf;

newbrt/tdb_logprint.c

@@ -5,18 +5,6 @@
 
 #include "includes.h"
 
-#include "brttypes.h"
-#include "log-internal.h"
-#include "log_header.h"
-#include "toku_assert.h"
-#include <arpa/inet.h>
-#include <ctype.h>
-#include <inttypes.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <sys/types.h>
-#include <zlib.h>
-
 #if 0
 static u_int32_t crc=0;
 static u_int32_t actual_len=0;

newbrt/tests/Makefile

@@ -42,6 +42,7 @@ else
  CFLAGS += -g 
  CFLAGS += -diag-enable port-win 
  CFLAGS += -diag-disable 177     # Don't complain about static variables that are not used.
+ CFLAGS += -diag-disable 869
  CFLAGS += -diag-disable 981     # Don't complain about "operands are evaluated in unspecified order".  This seems to be generated whenever more than one argument to a function or operand is computed by function call.
 endif
 LDFLAGS = $(OPTFLAGS) -g $(GCOV_FLAGS) $(PROF_FLAGS) -lpthread -lz

newbrt/tests/bread-test.c

-#include <arpa/inet.h>
+#include "../portability.h"
+
 #include <assert.h>
 #include <fcntl.h>
 #include <stdlib.h>

newbrt/tests/brt-test-named-db.c

 /* -*- mode: C; c-basic-offset: 4 -*- */
 #ident "Copyright (c) 2007, 2008 Tokutek Inc.  All rights reserved."
 
-#include "brt.h"
-#include "key.h"
+#include "includes.h"
 #include "test.h"
-#include "toku_assert.h"
-#include <unistd.h>
 
 static TOKUTXN const null_txn = 0;
 static DB * const null_db = 0;

newbrt/tests/brt-test0.c

 /* -*- mode: C; c-basic-offset: 4 -*- */
 #ident "Copyright (c) 2007, 2008 Tokutek Inc.  All rights reserved."
 
-#include "brt.h"
-#include "key.h"
+#include "includes.h"
 #include "test.h"
-#include "toku_assert.h"
-#include <unistd.h>
 
 static TOKUTXN const null_txn = 0;
 static DB * const null_db = 0;

newbrt/tests/brt-test1.c

 /* -*- mode: C; c-basic-offset: 4 -*- */
 #ident "Copyright (c) 2007, 2008 Tokutek Inc.  All rights reserved."
 
-#include "brt.h"
-#include "key.h"
+#include "includes.h"
 #include "test.h"
-#include "toku_assert.h"
-#include <unistd.h>
 
 static TOKUTXN const null_txn = 0;
 static DB * const null_db = 0;

newbrt/tests/brt-test2.c

 /* -*- mode: C; c-basic-offset: 4 -*- */
 #ident "Copyright (c) 2007, 2008 Tokutek Inc.  All rights reserved."
 
-#include "brt.h"
-#include "key.h"
+#include "includes.h"
 #include "test.h"
-#include "toku_assert.h"
-#include <unistd.h>
 
 static TOKUTXN const null_txn = 0;
 static DB * const null_db = 0;

newbrt/tests/brt-test5.c

 /* -*- mode: C; c-basic-offset: 4 -*- */
 #ident "Copyright (c) 2007, 2008 Tokutek Inc.  All rights reserved."
 
-#include "brt.h"
-#include "key.h"
+#include "includes.h"
 #include "test.h"
-#include "toku_assert.h"
-
-#include <string.h>
-#include <unistd.h>
 
 static TOKUTXN const null_txn = 0;
 static DB * const null_db = 0;

newbrt/tests/cachetable-test.c

@@ -266,7 +266,7 @@ static void flush_n (CACHEFILE f __attribute__((__unused__)), CACHEKEY key __att
 		     void *extra  __attribute__((__unused__)),
                      long size __attribute__((__unused__)),
 		     BOOL write_me __attribute__((__unused__)),    BOOL keep_me __attribute__((__unused__)),
-		     LSN modified_lsn __attribute__((__unused__)), BOOL rename_p __attribute ((__unused__))) {
+		     LSN modified_lsn __attribute__((__unused__)), BOOL rename_p __attribute__ ((__unused__))) {
     int *v = value;
     assert(*v==0);
 }

newbrt/tests/fifo-test.c

-#include "fifo.h"
-#include "memory.h"
-#include "toku_assert.h"
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
+#include "includes.h"
 
 int verbose;
 
@@ -53,7 +48,7 @@ test_fifo_enq (int n) {
     }
 
     i = 0;
-    FIFO_ITERATE(f, key, keylen, val, vallen, type, xid, ({
+    FIFO_ITERATE(f, key, keylen, val, vallen, type, xid, {
         if (verbose) printf("checkit %d %d\n", i, type);
         buildkey(i);
         buildval(i);
@@ -62,7 +57,7 @@ test_fifo_enq (int n) {
         assert(i % 256 == type);
 	assert((TXNID)i==xid);
         i += 1;
-    }));
+    });
     assert(i == n);
 
     if (thekey) free(thekey);

newbrt/tests/keyrange-dupsort-unflat.c

 /* -*- mode: C; c-basic-offset: 4 -*- */
 #ident "Copyright (c) 2008 Tokutek Inc.  All rights reserved."
 
-#include "brt.h"
+#include "includes.h"
 #include "test.h"
-#include "toku_assert.h"
-#include "key.h"
 
 #include <unistd.h>
 

newbrt/tests/keyrange-dupsort.c

 /* -*- mode: C; c-basic-offset: 4 -*- */
 #ident "Copyright (c) 2008 Tokutek Inc.  All rights reserved."
 
-#include "brt.h"
+#include "includes.h"
 #include "test.h"
-#include "toku_assert.h"
-#include "key.h"
 
 #include <unistd.h>
 

newbrt/tests/keyrange-unflat.c

 /* -*- mode: C; c-basic-offset: 4 -*- */
 #ident "Copyright (c) 2008 Tokutek Inc.  All rights reserved."
 
-#include "brt.h"
+#include "includes.h"
 #include "test.h"
-#include "toku_assert.h"
-#include "key.h"
 
 #include <unistd.h>
 

newbrt/tests/keyrange.c

 /* -*- mode: C; c-basic-offset: 4 -*- */
 #ident "Copyright (c) 2008 Tokutek Inc.  All rights reserved."
 
-#include "brt.h"
+#include "includes.h"
 #include "test.h"
-#include "toku_assert.h"
-#include "key.h"
 
 #include <unistd.h>
 

newbrt/tests/log-test.c

 /* -*- mode: C; c-basic-offset: 4 -*- */
 #ident "Copyright (c) 2007, 2008 Tokutek Inc.  All rights reserved."
 
-#include "log-internal.h"
-#include "toku_assert.h"
-#include <fcntl.h>
-#include <stdlib.h>
-#include <sys/stat.h>
-#include <sys/types.h>
-#include <unistd.h>
+#include "includes.h"
 
 #define dname __FILE__ ".dir"
 #define rmrf "rm -rf " dname "/"

newbrt/tests/log-test2.c

 /* -*- mode: C; c-basic-offset: 4 -*- */
 #ident "Copyright (c) 2007, 2008 Tokutek Inc.  All rights reserved."
 
-#include "log-internal.h"
-#include "toku_assert.h"
-#include <fcntl.h>
-#include <stdlib.h>
-#include <sys/stat.h>
-#include <sys/types.h>
-#include <unistd.h>
+#include "includes.h"
 
 #define dname __FILE__ ".dir"
 #define rmrf "rm -rf " dname "/"

newbrt/tests/log-test3.c

 /* -*- mode: C; c-basic-offset: 4 -*- */
 #ident "Copyright (c) 2007, 2008 Tokutek Inc.  All rights reserved."
 
-#include "log-internal.h"
-#include "toku_assert.h"
-#include <fcntl.h>
-#include <stdlib.h>
-#include <sys/stat.h>
-#include <sys/types.h>
-#include <unistd.h>
+#include "includes.h"
 
 #define dname __FILE__ ".dir"
 #define rmrf "rm -rf " dname "/"

newbrt/tests/log-test4.c

 /* -*- mode: C; c-basic-offset: 4 -*- */
 #ident "Copyright (c) 2007, 2008 Tokutek Inc.  All rights reserved."
 
-#include "log-internal.h"
-#include "toku_assert.h"
-#include <fcntl.h>
-#include <stdlib.h>
-#include <sys/stat.h>
-#include <sys/types.h>
-#include <unistd.h>
+#include "includes.h"
 
 #define dname __FILE__ ".dir"
 #define rmrf "rm -rf " dname "/"

newbrt/tests/log-test5.c

 /* -*- mode: C; c-basic-offset: 4 -*- */
 #ident "Copyright (c) 2007, 2008 Tokutek Inc.  All rights reserved."
 
-#include "log-internal.h"
-#include "toku_assert.h"
-#include <dirent.h>
-#include <fcntl.h>
-#include <stdlib.h>
-#include <sys/stat.h>
-#include <sys/types.h>
-#include <unistd.h>
+#include "includes.h"
 
 #define dname __FILE__ ".dir"
 #define rmrf "rm -rf " dname "/"

newbrt/tests/log-test6.c

 /* -*- mode: C; c-basic-offset: 4 -*- */
 #ident "Copyright (c) 2007, 2008 Tokutek Inc.  All rights reserved."
 
-#include "log-internal.h"
-#include "toku_assert.h"
-#include <fcntl.h>
-#include <stdlib.h>
-#include <sys/stat.h>
-#include <sys/types.h>
-#include <unistd.h>
+#include "includes.h"
 
 #define dname __FILE__ ".dir"
 #define rmrf "rm -rf " dname "/"

newbrt/tests/omt-test.c

@@ -8,9 +8,9 @@ typedef OMTVALUE TESTVALUE;
 /* Things that would go in a omt-tests.h if we split to multiple files later. */
 int verbose=0;
 
-#define CKERR(r) ({ if (r!=0) fprintf(stderr, "%s:%d error %d %s\n", __FILE__, __LINE__, r, strerror(r)); assert(r==0); })
-#define CKERR2(r,r2) ({ if (r!=r2) fprintf(stderr, "%s:%d error %d %s, expected %d\n", __FILE__, __LINE__, r, strerror(r), r2); assert(r==r2); })
-#define CKERR2s(r,r2,r3) ({ if (r!=r2 && r!=r3) fprintf(stderr, "%s:%d error %d %s, expected %d or %d\n", __FILE__, __LINE__, r, strerror(r), r2,r3); assert(r==r2||r==r3); })
+#define CKERR(r) do { if (r!=0) fprintf(stderr, "%s:%d error %d %s\n", __FILE__, __LINE__, r, strerror(r)); assert(r==0); } while (0)
+#define CKERR2(r,r2) do { if (r!=r2) fprintf(stderr, "%s:%d error %d %s, expected %d\n", __FILE__, __LINE__, r, strerror(r), r2); assert(r==r2); } while (0)
+#define CKERR2s(r,r2,r3) do { if (r!=r2 && r!=r3) fprintf(stderr, "%s:%d error %d %s, expected %d or %d\n", __FILE__, __LINE__, r, strerror(r), r2,r3); assert(r==r2||r==r3); } while (0)
 
 #include <string.h>
 static void

newbrt/tests/shortcut.c

-#include <assert.h>
-#include <string.h>
-#include <unistd.h>
-#include "brt.h"
-#include "key.h"
+#include "includes.h"
 
 static const char fname[]= __FILE__ ".brt";
 

newbrt/tests/test-assert.c

 /* -*- mode: C; c-basic-offset: 4 -*- */
-#include "toku_assert.h"
-#include "brttypes.h"
+#include "includes.h"
 #include <signal.h>
-#include <stdio.h>
-#include <string.h>
-#include <stdlib.h>
+
 
 static __attribute__((__noreturn__)) void catch_abort (int sig __attribute__((__unused__))) {
     exit(1);

newbrt/tests/test-brt-delete-both.c

@@ -4,11 +4,9 @@
  * they match both key and value.
  */
 
-#include <unistd.h>
-
-#include "brt.h"
+#include "includes.h"
 #include "test.h"
-#include "toku_assert.h"
+
 
 static TOKUTXN const null_txn = 0;
 

newbrt/tests/test-brt-overflow.c

 /* Test an overflow condition on the leaf.  See #632. */
 
-#include "brt.h"
-#include "key.h"
-#include "toku_assert.h"
-#include <string.h>
-#include <unistd.h>
+#include "includes.h"
 
 int verbose;
 

newbrt/tests/test_oexcl.c

 /* -*- mode: C; c-basic-offset: 4 -*- */
 #ident "Copyright (c) 2007, 2008 Tokutek Inc.  All rights reserved."
 
-#include "toku_assert.h"
-#include <errno.h>
-#include <fcntl.h>
-#include <stdlib.h>
-#include <stdio.h>
-#include <string.h>
-#include <sys/stat.h>
-#include <sys/types.h>
-#include <unistd.h>
-
+#include "includes.h"
 
 #define fname __FILE__ ".tmp"
 

newbrt/tests/x1764-test.c

-#include "x1764.h"
-#include "toku_assert.h"
-#include <stdio.h>
-#include <stdlib.h>
+#include "includes.h"
 
 static void
 test0 (void) {

newbrt/tests/ybt-test.c

 /* -*- mode: C; c-basic-offset: 4 -*- */
 #ident "Copyright (c) 2007, 2008 Tokutek Inc.  All rights reserved."
 
-#define _FILE_OFFSET_BITS 64
-
-#include "ybt.h"
-#include "memory.h"
-#include "toku_assert.h"
-#include <string.h>
+#include "includes.h"
 
 static void ybt_test0 (void) {
     void *v0=0,*v1=0;

newbrt/toku_assert.h

@@ -14,6 +14,6 @@ void toku_do_assert(int,const char*/*expr_as_string*/,const char */*fun*/,const
 #ifdef SLOW_ASSERT
 #define assert(expr) toku_do_assert((expr) != 0, #expr, __FUNCTION__, __FILE__, __LINE__)
 #else
-#define assert(expr) ({ if ((expr)==0) toku_do_assert(0, #expr, __FUNCTION__, __FILE__, __LINE__); })
+#define assert(expr) do { if ((expr)==0) toku_do_assert(0, #expr, __FUNCTION__, __FILE__, __LINE__); } while (0)
 #endif
 #endif