erts: Fix macro redefinition

LIST_NEXT and LIST_PREV causes macro redefinitions from other include files.

beam/erl_ao_firstfit_alloc.c:103:9: warning: 'LIST_NEXT' macro redefined [-Wmacro-redefined]
        ^
/usr/include/sys/queue.h:507:9: note: previous definition is here
        ^
1 warning generated.
beam/erl_bestfit_alloc.c:125:9: warning: 'LIST_NEXT' macro redefined [-Wmacro-redefined]
        ^
/usr/include/sys/queue.h:507:9: note: previous definition is here
        ^

2 files changed, 66 insertions, 68 deletions

diff --git a/erts/emulator/beam/erl_ao_firstfit_alloc.c b/erts/emulator/beam/erl_ao_firstfit_alloc.c
index 3f0ab33597..917cb1cf10 100644
--- a/erts/emulator/beam/erl_ao_firstfit_alloc.c
+++ b/erts/emulator/beam/erl_ao_firstfit_alloc.c
@@ -100,8 +100,8 @@
 
 #define AOFF_BLK_SZ(B) MBC_FBLK_SZ(&(B)->hdr)
 
-#define LIST_NEXT(N) (((AOFF_RBTree_t*)(N))->u.next)
-#define LIST_PREV(N) (((AOFF_RBTree_t*)(N))->parent)
+#define AOFF_LIST_NEXT(N) (((AOFF_RBTree_t*)(N))->u.next)
+#define AOFF_LIST_PREV(N) (((AOFF_RBTree_t*)(N))->parent)
 
 typedef struct AOFF_Carrier_t_ AOFF_Carrier_t;
 
@@ -152,13 +152,13 @@ static ERTS_INLINE Uint node_max_size(AOFF_RBTree_t *x)
 static ERTS_INLINE void lower_max_size(AOFF_RBTree_t *node,
 				       AOFF_RBTree_t* stop_at)
 {
-    AOFF_RBTree_t* x = node;    
+    AOFF_RBTree_t* x = node;
     Uint old_max = x->max_sz;
     Uint new_max = node_max_size(x);
 
     if (new_max < old_max) {
 	x->max_sz = new_max;
-	while ((x=x->parent) != stop_at && x->max_sz == old_max) {		
+	while ((x=x->parent) != stop_at && x->max_sz == old_max) {
 	    x->max_sz = node_max_size(x);
 	}
 	ASSERT(x == stop_at || x->max_sz > old_max);
@@ -352,7 +352,7 @@ left_rotate(AOFF_RBTree_t **root, AOFF_RBTree_t *x)
     x->parent = y;
 
     y->max_sz = x->max_sz;
-    x->max_sz = node_max_size(x); 
+    x->max_sz = node_max_size(x);
     ASSERT(y->max_sz >= x->max_sz);
 }
 
@@ -377,7 +377,7 @@ right_rotate(AOFF_RBTree_t **root, AOFF_RBTree_t *x)
     y->right = x;
     x->parent = y;
     y->max_sz = x->max_sz;
-    x->max_sz = node_max_size(x);    
+    x->max_sz = node_max_size(x);
     ASSERT(y->max_sz >= x->max_sz);
 }
 
@@ -523,23 +523,23 @@ aoff_unlink_free_block(Allctr_t *allctr, Block_t *blk)
 	ASSERT(del->flags & IS_BF_FLG);
 	if (IS_LIST_ELEM(del)) {
 	    /* Remove from list */
-	    ASSERT(LIST_PREV(del));
-	    ASSERT(LIST_PREV(del)->flags & IS_BF_FLG);
-	    LIST_NEXT(LIST_PREV(del)) = LIST_NEXT(del);
-	    if (LIST_NEXT(del)) {
-		ASSERT(LIST_NEXT(del)->flags & IS_BF_FLG);
-		LIST_PREV(LIST_NEXT(del)) = LIST_PREV(del);
+	    ASSERT(AOFF_LIST_PREV(del));
+	    ASSERT(AOFF_LIST_PREV(del)->flags & IS_BF_FLG);
+	    AOFF_LIST_NEXT(AOFF_LIST_PREV(del)) = AOFF_LIST_NEXT(del);
+	    if (AOFF_LIST_NEXT(del)) {
+		ASSERT(AOFF_LIST_NEXT(del)->flags & IS_BF_FLG);
+		AOFF_LIST_PREV(AOFF_LIST_NEXT(del)) = AOFF_LIST_PREV(del);
 	    }
 	    return;
 	}
-	else if (LIST_NEXT(del)) {
+	else if (AOFF_LIST_NEXT(del)) {
 	    /* Replace tree node by next element in list... */
-	    
-	    ASSERT(AOFF_BLK_SZ(LIST_NEXT(del)) == AOFF_BLK_SZ(del));
-	    ASSERT(IS_LIST_ELEM(LIST_NEXT(del)));
-	    
-	    replace(&crr->root, (AOFF_RBTree_t*)del, LIST_NEXT(del));
-	    
+
+	    ASSERT(AOFF_BLK_SZ(AOFF_LIST_NEXT(del)) == AOFF_BLK_SZ(del));
+	    ASSERT(IS_LIST_ELEM(AOFF_LIST_NEXT(del)));
+
+	    replace(&crr->root, (AOFF_RBTree_t*)del, AOFF_LIST_NEXT(del));
+
 	    HARD_CHECK_TREE(&crr->crr, alc->blk_order, crr->root, 0);
 	    return;
 	}
@@ -550,13 +550,13 @@ aoff_unlink_free_block(Allctr_t *allctr, Block_t *blk)
     HARD_CHECK_TREE(&crr->crr, alc->blk_order, crr->root, 0);
 
     /* Update the carrier tree with a potentially new (lower) max_sz
-     */    
+     */
     if (crr->root) {
 	if (crr->rbt_node.hdr.bhdr == crr->root->max_sz) {
 	    return;
 	}
 	ASSERT(crr->rbt_node.hdr.bhdr > crr->root->max_sz);
-	crr->rbt_node.hdr.bhdr = crr->root->max_sz; 
+	crr->rbt_node.hdr.bhdr = crr->root->max_sz;
     }
     else {
 	crr->rbt_node.hdr.bhdr = 0;
@@ -773,7 +773,7 @@ rbt_insert(enum AOFFSortOrder order, AOFF_RBTree_t** root, AOFF_RBTree_t* blk)
 #ifdef DEBUG
     blk->flags  = (order == FF_BF) ? IS_BF_FLG : 0;
 #else
-    blk->flags  = 0; 
+    blk->flags  = 0;
 #endif
     blk->left	= NULL;
     blk->right	= NULL;
@@ -787,7 +787,7 @@ rbt_insert(enum AOFFSortOrder order, AOFF_RBTree_t** root, AOFF_RBTree_t* blk)
     else {
 	AOFF_RBTree_t *x = *root;
 	while (1) {
-	    SWord diff; 
+	    SWord diff;
 	    if (x->max_sz < blk_sz) {
 		x->max_sz = blk_sz;
 	    }
@@ -810,14 +810,14 @@ rbt_insert(enum AOFFSortOrder order, AOFF_RBTree_t** root, AOFF_RBTree_t* blk)
 	    }
 	    else {
 		ASSERT(order == FF_BF);
-		ASSERT(blk->flags & IS_BF_FLG);			    
-		ASSERT(x->flags & IS_BF_FLG);			    
+		ASSERT(blk->flags & IS_BF_FLG);
+		ASSERT(x->flags & IS_BF_FLG);
 		SET_LIST_ELEM(blk);
-		LIST_NEXT(blk) = LIST_NEXT(x);
-		LIST_PREV(blk) = x;
-		if (LIST_NEXT(x))
-		    LIST_PREV(LIST_NEXT(x)) = blk;
-		LIST_NEXT(x) = blk;
+		AOFF_LIST_NEXT(blk) = AOFF_LIST_NEXT(x);
+		AOFF_LIST_PREV(blk) = x;
+		if (AOFF_LIST_NEXT(x))
+		    AOFF_LIST_PREV(AOFF_LIST_NEXT(x)) = blk;
+		AOFF_LIST_NEXT(x) = blk;
 		return;
 	    }
 	}
@@ -831,7 +831,7 @@ rbt_insert(enum AOFFSortOrder order, AOFF_RBTree_t** root, AOFF_RBTree_t* blk)
     }
     if (order == FF_BF) {
 	SET_TREE_NODE(blk);
-	LIST_NEXT(blk) = NULL;
+	AOFF_LIST_NEXT(blk) = NULL;
     }
 }
 
@@ -878,7 +878,7 @@ aoff_get_free_block(Allctr_t *allctr, Uint size,
 #ifdef HARD_DEBUG
     AOFF_RBTree_t* dbg_blk;
 #endif
-    
+
     ASSERT(!cand_blk || cand_size >= size);
 
     /* Get first-fit carrier
@@ -964,7 +964,7 @@ static void aoff_add_mbc(Allctr_t *allctr, Carrier_t *carrier)
     AOFF_RBTree_t **root = &alc->mbc_root;
 
     ASSERT(!IS_CRR_IN_TREE(crr, *root));
-    HARD_CHECK_TREE(NULL, alc->crr_order, *root, 0);   
+    HARD_CHECK_TREE(NULL, alc->crr_order, *root, 0);
 
     rbt_insert(alc->crr_order, root, &crr->rbt_node);
 
@@ -1105,7 +1105,7 @@ info_options(Allctr_t *allctr,
     }
 
     if (hpp || szp) {
-	
+
 	if (!atoms_initialized)
 	    erts_exit(ERTS_ERROR_EXIT, "%s:%d: Internal error: Atoms not initialized",
 		     __FILE__, __LINE__);;
@@ -1132,7 +1132,7 @@ erts_aoffalc_test(UWord op, UWord a1, UWord a2)
     switch (op) {
     case 0x500: return (UWord) ((AOFFAllctr_t *) a1)->blk_order == FF_AOBF;
     case 0x501: {
-	AOFF_RBTree_t *node = ((AOFFAllctr_t *) a1)->mbc_root; 
+	AOFF_RBTree_t *node = ((AOFFAllctr_t *) a1)->mbc_root;
 	Uint size = (Uint) a2;
 	node = node ? rbt_search(node, size) : NULL;
 	return (UWord) (node ? RBT_NODE_TO_MBC(node)->root : NULL);
@@ -1140,13 +1140,13 @@ erts_aoffalc_test(UWord op, UWord a1, UWord a2)
     case 0x502:	return (UWord) ((AOFF_RBTree_t *) a1)->parent;
     case 0x503:	return (UWord) ((AOFF_RBTree_t *) a1)->left;
     case 0x504:	return (UWord) ((AOFF_RBTree_t *) a1)->right;
-    case 0x505:	return (UWord) LIST_NEXT(a1);
+    case 0x505:	return (UWord) AOFF_LIST_NEXT(a1);
     case 0x506:	return (UWord) IS_BLACK((AOFF_RBTree_t *) a1);
     case 0x507:	return (UWord) IS_TREE_NODE((AOFF_RBTree_t *) a1);
     case 0x508: return (UWord) 0; /* IS_BF_ALGO */
     case 0x509: return (UWord) ((AOFF_RBTree_t *) a1)->max_sz;
     case 0x50a: return (UWord) ((AOFFAllctr_t *) a1)->blk_order == FF_BF;
-    case 0x50b:	return (UWord) LIST_PREV(a1);
+    case 0x50b:	return (UWord) AOFF_LIST_PREV(a1);
     default:	ASSERT(0); return ~((UWord) 0);
     }
 }
@@ -1166,7 +1166,7 @@ static int rbt_is_member(AOFF_RBTree_t* root, AOFF_RBTree_t* node)
             return 0;
         }
 	node = node->parent;
-    }    
+    }
     return 1;
 }
 
@@ -1279,15 +1279,15 @@ check_tree(Carrier_t* within_crr, enum AOFFSortOrder order, AOFF_RBTree_t* root,
 	}
 	if (order == FF_BF) {
 	    AOFF_RBTree_t* y = x;
-	    AOFF_RBTree_t* nxt = LIST_NEXT(y);
+	    AOFF_RBTree_t* nxt = AOFF_LIST_NEXT(y);
 	    ASSERT(IS_TREE_NODE(x));
 	    while (nxt) {
 		ASSERT(IS_LIST_ELEM(nxt));
 		ASSERT(AOFF_BLK_SZ(nxt) == AOFF_BLK_SZ(x));
 		ASSERT(FBLK_TO_MBC(&nxt->hdr) == within_crr);
-		ASSERT(LIST_PREV(nxt) == y);
+		ASSERT(AOFF_LIST_PREV(nxt) == y);
 		y = nxt;
-		nxt = LIST_NEXT(nxt);
+		nxt = AOFF_LIST_NEXT(nxt);
 	    }
 	}
 
@@ -1301,13 +1301,13 @@ check_tree(Carrier_t* within_crr, enum AOFFSortOrder order, AOFF_RBTree_t* root,
 	if (x->left) {
 	    ASSERT(x->left->parent == x);
 	    ASSERT(cmp_blocks(order, x->left, x) < 0);
-	    ASSERT(x->left->max_sz <= x->max_sz);	    
+	    ASSERT(x->left->max_sz <= x->max_sz);
 	}
 
 	if (x->right) {
 	    ASSERT(x->right->parent == x);
 	    ASSERT(cmp_blocks(order, x->right, x) > 0);
-	    ASSERT(x->right->max_sz <= x->max_sz);	    
+	    ASSERT(x->right->max_sz <= x->max_sz);
 	}
 	ASSERT(x->max_sz >= AOFF_BLK_SZ(x));
 	ASSERT(x->max_sz == AOFF_BLK_SZ(x)
@@ -1327,7 +1327,7 @@ check_tree(Carrier_t* within_crr, enum AOFFSortOrder order, AOFF_RBTree_t* root,
 	x = x->parent;
 	--depth;
     }
-    ASSERT(depth == 0 || (!root && depth==1)); 
+    ASSERT(depth == 0 || (!root && depth==1));
     ASSERT(curr_blacks == 0);
     ASSERT((1 << (max_depth/2)) <= node_cnt);
 
@@ -1373,4 +1373,3 @@ print_tree(AOFF_RBTree_t* root)
 #endif /* PRINT_TREE */
 
 #endif /* HARD_DEBUG */
-
diff --git a/erts/emulator/beam/erl_bestfit_alloc.c b/erts/emulator/beam/erl_bestfit_alloc.c
index 9cb1199c2a..3f981ca2bc 100644
--- a/erts/emulator/beam/erl_bestfit_alloc.c
+++ b/erts/emulator/beam/erl_bestfit_alloc.c
@@ -122,8 +122,8 @@ typedef struct {
     RBTree_t *next;
 } RBTreeList_t;
 
-#define LIST_NEXT(N) (((RBTreeList_t *) (N))->next)
-#define LIST_PREV(N) (((RBTreeList_t *) (N))->t.parent)
+#define BF_LIST_NEXT(N) (((RBTreeList_t *) (N))->next)
+#define BF_LIST_PREV(N) (((RBTreeList_t *) (N))->t.parent)
 
 
 #ifdef DEBUG
@@ -593,7 +593,6 @@ aobf_link_free_block(Allctr_t *allctr, Block_t *block)
     RBTree_t *blk = (RBTree_t *) block;
     Uint blk_sz = BF_BLK_SZ(blk);
 
-    
 
     blk->flags	= 0;
     blk->left	= NULL;
@@ -673,7 +672,7 @@ aobf_get_free_block(Allctr_t *allctr, Uint size,
 	    x = x->left;
 	}
     }
-    
+
     if (!blk)
 	return NULL;
 
@@ -729,11 +728,11 @@ bf_link_free_block(Allctr_t *allctr, Block_t *block)
 	    if (blk_sz == size) {
 
 		SET_LIST_ELEM(blk);
-		LIST_NEXT(blk) = LIST_NEXT(x);
-		LIST_PREV(blk) = x;
-		if (LIST_NEXT(x))
-		    LIST_PREV(LIST_NEXT(x)) = blk;
-		LIST_NEXT(x) = blk;
+		BF_LIST_NEXT(blk) = BF_LIST_NEXT(x);
+		BF_LIST_PREV(blk) = x;
+		if (BF_LIST_NEXT(x))
+		    BF_LIST_PREV(BF_LIST_NEXT(x)) = blk;
+		BF_LIST_NEXT(x) = blk;
 
 		return; /* Finnished */
 	    }
@@ -764,7 +763,7 @@ bf_link_free_block(Allctr_t *allctr, Block_t *block)
     }
 
     SET_TREE_NODE(blk);
-    LIST_NEXT(blk) = NULL;
+    BF_LIST_NEXT(blk) = NULL;
 
 #ifdef HARD_DEBUG
     check_tree(root, 0, 0);
@@ -780,22 +779,22 @@ bf_unlink_free_block(Allctr_t *allctr, Block_t *block)
 
     if (IS_LIST_ELEM(x)) {
 	/* Remove from list */
-	ASSERT(LIST_PREV(x));
-	LIST_NEXT(LIST_PREV(x)) = LIST_NEXT(x);
-	if (LIST_NEXT(x))
-	    LIST_PREV(LIST_NEXT(x)) = LIST_PREV(x);
+	ASSERT(BF_LIST_PREV(x));
+	BF_LIST_NEXT(BF_LIST_PREV(x)) = BF_LIST_NEXT(x);
+	if (BF_LIST_NEXT(x))
+	    BF_LIST_PREV(BF_LIST_NEXT(x)) = BF_LIST_PREV(x);
     }
-    else if (LIST_NEXT(x)) {
+    else if (BF_LIST_NEXT(x)) {
 	/* Replace tree node by next element in list... */
 
-	ASSERT(BF_BLK_SZ(LIST_NEXT(x)) == BF_BLK_SZ(x));
+	ASSERT(BF_BLK_SZ(BF_LIST_NEXT(x)) == BF_BLK_SZ(x));
 	ASSERT(IS_TREE_NODE(x));
-	ASSERT(IS_LIST_ELEM(LIST_NEXT(x)));
+	ASSERT(IS_LIST_ELEM(BF_LIST_NEXT(x)));
 
 #ifdef HARD_DEBUG
 	check_tree(root, 0, 0);
 #endif
-	replace(root, x, LIST_NEXT(x));
+	replace(root, x, BF_LIST_NEXT(x));
 
 #ifdef HARD_DEBUG
 	check_tree(bfallctr, 0);
@@ -834,7 +833,7 @@ bf_get_free_block(Allctr_t *allctr, Uint size,
 	    x = x->left;
 	}
     }
-    
+
     if (!blk)
 	return NULL;
 
@@ -853,7 +852,7 @@ bf_get_free_block(Allctr_t *allctr, Uint size,
 
     /* Use next block if it exist in order to avoid replacing
        the tree node */
-    blk = LIST_NEXT(blk) ? LIST_NEXT(blk) : blk;
+    blk = BF_LIST_NEXT(blk) ? BF_LIST_NEXT(blk) : blk;
 
     bf_unlink_free_block(allctr, (Block_t *) blk);
     return (Block_t *) blk;
@@ -938,7 +937,7 @@ info_options(Allctr_t *allctr,
     }
 
     if (hpp || szp) {
-	
+
 	if (!atoms_initialized)
 	    erts_exit(ERTS_ERROR_EXIT, "%s:%d: Internal error: Atoms not initialized",
 		     __FILE__, __LINE__);;
@@ -969,12 +968,12 @@ erts_bfalc_test(UWord op, UWord a1, UWord a2)
     case 0x202:	return (UWord) ((RBTree_t *) a1)->parent;
     case 0x203:	return (UWord) ((RBTree_t *) a1)->left;
     case 0x204:	return (UWord) ((RBTree_t *) a1)->right;
-    case 0x205:	return (UWord) LIST_NEXT(a1);
+    case 0x205:	return (UWord) BF_LIST_NEXT(a1);
     case 0x206:	return (UWord) IS_BLACK((RBTree_t *) a1);
     case 0x207:	return (UWord) IS_TREE_NODE((RBTree_t *) a1);
     case 0x208:	return (UWord) 1; /* IS_BF_ALGO */
     case 0x20a: return (UWord) !((BFAllctr_t *) a1)->address_order; /* IS_BF */
-    case 0x20b:	return (UWord) LIST_PREV(a1);
+    case 0x20b:	return (UWord) BF_LIST_PREV(a1);
     default:	ASSERT(0); return ~((UWord) 0);
     }
 }