Index: pbx/dundi-parser.c
===================================================================
--- pbx/dundi-parser.c	(revision 128490)
+++ pbx/dundi-parser.c	(working copy)
@@ -71,7 +71,7 @@
 	if (sscanf(s, "%2x%2x%2x%2x%2x%2x", &eid_int[0], &eid_int[1], &eid_int[2],
 		 &eid_int[3], &eid_int[4], &eid_int[5]) != 6)
 		 	return -1;
-	for (x=0;x<6;x++)
+	for (x = 0; x < 6; x++)
 		eid->eid[x] = eid_int[x];
 	return 0;
 }
@@ -79,7 +79,7 @@
 int dundi_eid_zero(dundi_eid *eid)
 {
 	int x;
-	for (x=0;x<sizeof(eid->eid) / sizeof(eid->eid[0]);x++)
+	for (x = 0; x < ARRAY_LEN(eid->eid); x++)
 		if (eid->eid[x]) return 0;
 	return 1;
 }
Index: channels/h323/ast_h323.cxx
===================================================================
--- channels/h323/ast_h323.cxx	(revision 128490)
+++ channels/h323/ast_h323.cxx	(working copy)
@@ -970,7 +970,7 @@
 	Q931 tmpQ931;
 	Q931 &q931 = pdu.GetQ931();
 
-	for(unsigned i = 0; i < (sizeof(codes) / sizeof(codes[0])); ++i) {
+	for(unsigned i = 0; i < ARRAY_LEN(codes); ++i) {
 		if (q931.HasIE(codes[i].ie)) {
 			tmpQ931.SetIE(codes[i].ie, q931.GetIE(codes[i].ie));
 			if (!codes[i].dontDelete)
@@ -1104,7 +1104,7 @@
 	q931.Encode(message);
 
 	/* Remove non-standard IEs */
-	for(unsigned i = 0; i < (sizeof(codes) / sizeof(codes[0])); ++i) {
+	for(unsigned i = 0; i < ARRAY_LEN(codes); ++i) {
 		if (q931.HasIE(codes[i])) {
 			q931.RemoveIE(codes[i]);
 		}
Index: channels/chan_dahdi.c
===================================================================
--- channels/chan_dahdi.c	(revision 128490)
+++ channels/chan_dahdi.c	(working copy)
@@ -1344,7 +1344,7 @@
 static char *alarm2str(int alarm)
 {
 	int x;
-	for (x = 0; x < sizeof(alarms) / sizeof(alarms[0]); x++) {
+	for (x = 0; x < ARRAY_LEN(alarms); x++) {
 		if (alarms[x].alarm & alarm)
 			return alarms[x].name;
 	}
@@ -1697,7 +1697,7 @@
 
 	switch (law) {
 	case DAHDI_LAW_ALAW:
-		for (j = 0; j < (sizeof(g->txgain) / sizeof(g->txgain[0])); j++) {
+		for (j = 0; j < ARRAY_LEN(g->txgain); j++) {
 			if (gain) {
 				k = (int) (((float) AST_ALAW(j)) * linear_gain);
 				if (k > 32767) k = 32767;
@@ -1709,7 +1709,7 @@
 		}
 		break;
 	case DAHDI_LAW_MULAW:
-		for (j = 0; j < (sizeof(g->txgain) / sizeof(g->txgain[0])); j++) {
+		for (j = 0; j < ARRAY_LEN(g->txgain); j++) {
 			if (gain) {
 				k = (int) (((float) AST_MULAW(j)) * linear_gain);
 				if (k > 32767) k = 32767;
@@ -1731,7 +1731,7 @@
 
 	switch (law) {
 	case DAHDI_LAW_ALAW:
-		for (j = 0; j < (sizeof(g->rxgain) / sizeof(g->rxgain[0])); j++) {
+		for (j = 0; j < ARRAY_LEN(g->rxgain); j++) {
 			if (gain) {
 				k = (int) (((float) AST_ALAW(j)) * linear_gain);
 				if (k > 32767) k = 32767;
@@ -1743,7 +1743,7 @@
 		}
 		break;
 	case DAHDI_LAW_MULAW:
-		for (j = 0; j < (sizeof(g->rxgain) / sizeof(g->rxgain[0])); j++) {
+		for (j = 0; j < ARRAY_LEN(g->rxgain); j++) {
 			if (gain) {
 				k = (int) (((float) AST_MULAW(j)) * linear_gain);
 				if (k > 32767) k = 32767;
@@ -6891,7 +6891,7 @@
 						len = 0;
 						distMatches = 0;
 						/* Clear the current ring data array so we dont have old data in it. */
-						for (receivedRingT = 0; receivedRingT < (sizeof(curRingData) / sizeof(curRingData[0])); receivedRingT++)
+						for (receivedRingT = 0; receivedRingT < ARRAY_LEN(curRingData); receivedRingT++)
 							curRingData[receivedRingT] = 0;
 						receivedRingT = 0;
 						counter = 0;
@@ -7040,7 +7040,7 @@
 				len = 0;
 				distMatches = 0;
 				/* Clear the current ring data array so we dont have old data in it. */
-				for (receivedRingT = 0; receivedRingT < (sizeof(curRingData) / sizeof(curRingData[0])); receivedRingT++)
+				for (receivedRingT = 0; receivedRingT < ARRAY_LEN(curRingData); receivedRingT++)
 					curRingData[receivedRingT] = 0;
 				receivedRingT = 0;
 				counter = 0;
Index: channels/chan_sip.c
===================================================================
--- channels/chan_sip.c	(revision 128490)
+++ channels/chan_sip.c	(working copy)
@@ -2631,7 +2631,7 @@
 		next = ast_skip_blanks(next);
 		if (sipdebug)
 			ast_debug(3, "Found SIP option: -%s-\n", next);
-		for (i=0; i < (sizeof(sip_options) / sizeof(sip_options[0])); i++) {
+		for (i = 0; i < ARRAY_LEN(sip_options); i++) {
 			if (!strcasecmp(next, sip_options[i].text)) {
 				profile |= sip_options[i].id;
 				found = TRUE;
@@ -5706,9 +5706,10 @@
 	};
 	int x;
 
-	for (x=0; x<sizeof(aliases) / sizeof(aliases[0]); x++) 
+	for (x = 0; x < ARRAY_LEN(aliases); x++) {
 		if (!strcasecmp(aliases[x].fullname, name))
 			return aliases[x].shortname;
+	}
 
 	return _default;
 }
@@ -13104,7 +13105,7 @@
 		ast_cli(fd, "  SIP Options  : ");
 		if (peer->sipoptions) {
 			int lastoption = -1;
-			for (x=0 ; (x < (sizeof(sip_options) / sizeof(sip_options[0]))); x++) {
+			for (x = 0 ; x < ARRAY_LEN(sip_options); x++) {
 				if (sip_options[x].id != lastoption) {
 					if (peer->sipoptions & sip_options[x].id)
 						ast_cli(fd, "%s ", sip_options[x].text);
@@ -13964,7 +13965,7 @@
 			ast_cli(a->fd, "  SIP Options:            ");
 			if (cur->sipoptions) {
 				int x;
-				for (x=0 ; (x < (sizeof(sip_options) / sizeof(sip_options[0]))); x++) {
+				for (x = 0 ; x < ARRAY_LEN(sip_options); x++) {
 					if (cur->sipoptions & sip_options[x].id)
 						ast_cli(a->fd, "%s ", sip_options[x].text);
 				}
Index: channels/iax2-provision.c
===================================================================
--- channels/iax2-provision.c	(revision 128490)
+++ channels/iax2-provision.c	(working copy)
@@ -87,7 +87,7 @@
 	
 	buf[0] = '\0';
 
-	for (x = 0; x < sizeof(iax_flags) / sizeof(iax_flags[0]); x++) {
+	for (x = 0; x < ARRAY_LEN(iax_flags); x++) {
 		if (flags & iax_flags[x].value){
 			strncat(buf, iax_flags[x].name, buflen - strlen(buf) - 1);
 			strncat(buf, ",", buflen - strlen(buf) - 1);
@@ -116,7 +116,7 @@
 		else
 			len = 0;
 		found = 0;
-		for (x=0;x<sizeof(iax_flags) / sizeof(iax_flags[0]); x++) {
+		for (x = 0; x < ARRAY_LEN(iax_flags); x++) {
 			if ((len && !strncasecmp(iax_flags[x].name, buf, len)) ||
 			    (!len && !strcasecmp(iax_flags[x].name, buf))) {
 				flags |= iax_flags[x].value;
Index: channels/chan_iax2.c
===================================================================
--- channels/chan_iax2.c	(revision 128490)
+++ channels/chan_iax2.c	(working copy)
@@ -2786,23 +2786,27 @@
 		if (dp->flags & CACHE_FLAG_UNKNOWN)
 			strncat(tmp, "UNKNOWN|", sizeof(tmp) - strlen(tmp) - 1);
 		/* Trim trailing pipe */
-		if (!ast_strlen_zero(tmp))
+		if (!ast_strlen_zero(tmp)) {
 			tmp[strlen(tmp) - 1] = '\0';
-		else
+		} else {
 			ast_copy_string(tmp, "(none)", sizeof(tmp));
+		}
 		y = 0;
 		pc = strchr(dp->peercontext, '@');
-		if (!pc)
+		if (!pc) {
 			pc = dp->peercontext;
-		else
+		} else {
 			pc++;
-		for (x = 0; x < sizeof(dp->waiters) / sizeof(dp->waiters[0]); x++)
+		}
+		for (x = 0; x < ARRAY_LEN(dp->waiters); x++) {
 			if (dp->waiters[x] > -1)
 				y++;
-		if (s > 0)
+		}
+		if (s > 0) {
 			ast_cli(a->fd, "%-20.20s %-12.12s %-9d %-8d %s\n", pc, dp->exten, s, y, tmp);
-		else
+		} else {
 			ast_cli(a->fd, "%-20.20s %-12.12s %-9.9s %-8d %s\n", pc, dp->exten, "(expired)", y, tmp);
+		}
 	}
 
 	AST_LIST_LOCK(&dpcache);
@@ -6523,9 +6527,10 @@
 			dp->flags |= matchmore;
 		}
 		/* Wake up waiters */
-		for (x=0;x<sizeof(dp->waiters) / sizeof(dp->waiters[0]); x++)
+		for (x = 0; x < ARRAY_LEN(dp->waiters); x++) {
 			if (dp->waiters[x] > -1)
 				write(dp->waiters[x], "asdf", 4);
+		}
 	}
 	AST_LIST_TRAVERSE_SAFE_END;
 	AST_LIST_UNLOCK(&dpcache);
@@ -11436,7 +11441,7 @@
 		/* Expires in 30 mins by default */
 		dp->expiry.tv_sec += iaxdefaultdpcache;
 		dp->flags = CACHE_FLAG_PENDING;
-		for (x=0;x<sizeof(dp->waiters) / sizeof(dp->waiters[0]); x++)
+		for (x = 0; x < ARRAY_LEN(dp->waiters); x++)
 			dp->waiters[x] = -1;
 		/* Insert into the lists */
 		AST_LIST_INSERT_TAIL(&dpcache, dp, cache_list);
@@ -11451,12 +11456,12 @@
 	if (dp->flags & CACHE_FLAG_PENDING) {
 		/* Okay, here it starts to get nasty.  We need a pipe now to wait
 		   for a reply to come back so long as it's pending */
-		for (x=0;x<sizeof(dp->waiters) / sizeof(dp->waiters[0]); x++) {
+		for (x = 0; x < ARRAY_LEN(dp->waiters); x++) {
 			/* Find an empty slot */
 			if (dp->waiters[x] < 0)
 				break;
 		}
-		if (x >= sizeof(dp->waiters) / sizeof(dp->waiters[0])) {
+		if (x >= ARRAY_LEN(dp->waiters)) {
 			ast_log(LOG_WARNING, "No more waiter positions available\n");
 			return NULL;
 		}
@@ -11509,9 +11514,10 @@
 				/* Expire after only 60 seconds now.  This is designed to help reduce backlog in heavily loaded
 				   systems without leaving it unavailable once the server comes back online */
 				dp->expiry.tv_sec = dp->orig.tv_sec + 60;
-				for (x=0;x<sizeof(dp->waiters) / sizeof(dp->waiters[0]); x++)
+				for (x = 0; x < ARRAY_LEN(dp->waiters); x++) {
 					if (dp->waiters[x] > -1)
 						write(dp->waiters[x], "asdf", 4);
+				}
 			}
 		}
 		/* Our caller will obtain the rest */
Index: apps/app_adsiprog.c
===================================================================
--- apps/app_adsiprog.c	(revision 128490)
+++ apps/app_adsiprog.c	(working copy)
@@ -515,7 +515,7 @@
 {
 	int x;
 
-	for (x = 0; x < sizeof(events) / sizeof(events[0]); x++) {
+	for (x = 0; x < ARRAY_LEN(events); x++) {
 		if (!strcasecmp(events[x].name, name))
 			return events[x].id;
 	}
@@ -527,7 +527,7 @@
 {
 	int x;
 
-	for (x = 0; x <sizeof(justify) / sizeof(justify[0]); x++) {
+	for (x = 0; x < ARRAY_LEN(justify); x++) {
 		if (!strcasecmp(justify[x].name, name))
 			return justify[x].id;
 	}
@@ -935,7 +935,7 @@
 	int x, res;
 	char *unused;
 
-	for (x = 0; x < sizeof(kcmds) / sizeof(kcmds[0]); x++) {
+	for (x = 0; x < ARRAY_LEN(kcmds); x++) {
 		if ((kcmds[x].id > -1) && !strcasecmp(kcmds[x].name, code)) {
 			if (kcmds[x].add_args) {
 				res = kcmds[x].add_args(key->retstr + key->retstrlen,
@@ -964,7 +964,7 @@
 	int x, res, max = sub->id ? MAX_SUB_LEN : MAX_MAIN_LEN;
 	char *unused;
 
-	for (x = 0; x < sizeof(opcmds) / sizeof(opcmds[0]); x++) {
+	for (x = 0; x < ARRAY_LEN(opcmds); x++) {
 		if ((opcmds[x].id > -1) && !strcasecmp(opcmds[x].name, code)) {
 			if (opcmds[x].add_args) {
 				res = opcmds[x].add_args(sub->data + sub->datalen,
Index: apps/app_parkandannounce.c
===================================================================
--- apps/app_parkandannounce.c	(revision 128490)
+++ apps/app_parkandannounce.c	(working copy)
@@ -146,7 +146,7 @@
 
 	ast_verb(4, "Announce Template:%s\n", args.template);
 
-	for (looptemp = 0; looptemp < sizeof(tmp) / sizeof(tmp[0]); looptemp++) {
+	for (looptemp = 0; looptemp < ARRAY_LEN(tmp); looptemp++) {
 		if ((tmp[looptemp] = strsep(&args.template, ":")) != NULL)
 			continue;
 		else
Index: apps/app_meetme.c
===================================================================
--- apps/app_meetme.c	(revision 128490)
+++ apps/app_meetme.c	(working copy)
@@ -3101,7 +3101,7 @@
 			/* Select first conference number not in use */
 			if (ast_strlen_zero(confno) && dynamic) {
 				AST_LIST_LOCK(&confs);
-				for (i = 0; i < sizeof(conf_map) / sizeof(conf_map[0]); i++) {
+				for (i = 0; i < ARRAY_LEN(conf_map); i++) {
 					if (!conf_map[i]) {
 						snprintf(confno, sizeof(confno), "%d", i);
 						conf_map[i] = 1;
Index: main/channel.c
===================================================================
--- main/channel.c	(revision 128490)
+++ main/channel.c	(working copy)
@@ -752,7 +752,7 @@
 	fmts &= AST_FORMAT_AUDIO_MASK;
 	
 	/* Find the first preferred codec in the format given */
-	for (x = 0; x < (sizeof(prefs) / sizeof(prefs[0]) ); x++) {
+	for (x = 0; x < ARRAY_LEN(prefs); x++) {
 		if (fmts & prefs[x])
 			return prefs[x];
 	}
Index: main/manager.c
===================================================================
--- main/manager.c	(revision 128490)
+++ main/manager.c	(working copy)
@@ -345,7 +345,7 @@
 	char *sep = "";
 
 	(*res)->used = 0;
-	for (i = 0; i < (sizeof(perms) / sizeof(perms[0])) - 1; i++) {
+	for (i = 0; i < ARRAY_LEN(perms) - 1; i++) {
 		if (authority & perms[i].num) {
 			ast_str_append(res, 0, "%s%s", sep, perms[i].label);
 			sep = ",";
@@ -387,7 +387,7 @@
 	if (!instr)
 		return 0;
 
-	for (x = 0; x < (sizeof(perms) / sizeof(perms[0])); x++) {
+	for (x = 0; x < ARRAY_LEN(perms); x++) {
 		if (ast_instring(instr, perms[x].label, ','))
 			ret |= perms[x].num;
 	}
@@ -415,7 +415,7 @@
 		return 0;
 	if (ast_true(string)) {	/* all permissions */
 		int x, ret = 0;
-		for (x = 0; x<sizeof(perms) / sizeof(perms[0]); x++)
+		for (x = 0; x < ARRAY_LEN(perms); x++)
 			ret |= perms[x].num;
 		return ret;
 	}
Index: main/acl.c
===================================================================
--- main/acl.c	(revision 128490)
+++ main/acl.c	(working copy)
@@ -434,7 +434,7 @@
 		return 0;
 	}
 
-	for (x = 0; x < sizeof(dscp_pool1) / sizeof(dscp_pool1[0]); x++) {
+	for (x = 0; x < ARRAY_LEN(dscp_pool1); x++) {
 		if (!strcasecmp(value, dscp_pool1[x].name)) {
 			*tos = dscp_pool1[x].space << 2;
 			return 0;
@@ -448,7 +448,7 @@
 {
 	unsigned int x;
 
-	for (x = 0; x < sizeof(dscp_pool1) / sizeof(dscp_pool1[0]); x++) {
+	for (x = 0; x < ARRAY_LEN(dscp_pool1); x++) {
 		if (dscp_pool1[x].space == (tos >> 2))
 			return dscp_pool1[x].name;
 	}
Index: main/rtp.c
===================================================================
--- main/rtp.c	(revision 128490)
+++ main/rtp.c	(working copy)
@@ -2205,7 +2205,7 @@
 	
 	rtp_bridge_lock(rtp);
 
-	for (i = 0; i < sizeof(mimeTypes)/sizeof(mimeTypes[0]); ++i) {
+	for (i = 0; i < ARRAY_LEN(mimeTypes); ++i) {
 		if (strcasecmp(mimeSubtype, mimeTypes[i].subtype) == 0 &&
 		    strcasecmp(mimeType, mimeTypes[i].type) == 0) {
 			found = 1;
@@ -2312,7 +2312,7 @@
 {
 	unsigned int i;
 
-	for (i = 0; i < sizeof(mimeTypes)/sizeof(mimeTypes[0]); ++i) {
+	for (i = 0; i < ARRAY_LEN(mimeTypes); ++i) {
 		if ((mimeTypes[i].payloadType.code == code) && (mimeTypes[i].payloadType.isAstFormat == isAstFormat)) {
 			if (isAstFormat &&
 			    (code == AST_FORMAT_G726_AAL2) &&
Index: main/frame.c
===================================================================
--- main/frame.c	(revision 128490)
+++ main/frame.c	(working copy)
@@ -503,7 +503,7 @@
 
 struct ast_format_list *ast_get_format_list(size_t *size) 
 {
-	*size = (sizeof(AST_FORMAT_LIST) / sizeof(AST_FORMAT_LIST[0]));
+	*size = ARRAY_LEN(AST_FORMAT_LIST);
 	return AST_FORMAT_LIST;
 }
 
@@ -511,7 +511,7 @@
 {
 	int x;
 	char *ret = "unknown";
-	for (x = 0; x < sizeof(AST_FORMAT_LIST) / sizeof(AST_FORMAT_LIST[0]); x++) {
+	for (x = 0; x < ARRAY_LEN(AST_FORMAT_LIST); x++) {
 		if (AST_FORMAT_LIST[x].bits == format) {
 			ret = AST_FORMAT_LIST[x].name;
 			break;
@@ -533,7 +533,7 @@
 	end += len;
 	size -= len;
 	start = end;
-	for (x = 0; x < sizeof(AST_FORMAT_LIST) / sizeof(AST_FORMAT_LIST[0]); x++) {
+	for (x = 0; x < ARRAY_LEN(AST_FORMAT_LIST); x++) {
 		if (AST_FORMAT_LIST[x].bits & format) {
 			snprintf(end, size,"%s|",AST_FORMAT_LIST[x].name);
 			len = strlen(end);
@@ -561,7 +561,7 @@
 {
 	int x;
 
-	for (x = 0; x < sizeof(ast_codec_alias_table) / sizeof(ast_codec_alias_table[0]); x++) {
+	for (x = 0; x < ARRAY_LEN(ast_codec_alias_table); x++) {
 		if (!strcmp(in,ast_codec_alias_table[x].alias))
 			return ast_codec_alias_table[x].realname;
 	}
@@ -573,7 +573,7 @@
 	int x, all, format = 0;
 
 	all = strcasecmp(name, "all") ? 0 : 1;
-	for (x = 0; x < sizeof(AST_FORMAT_LIST) / sizeof(AST_FORMAT_LIST[0]); x++) {
+	for (x = 0; x < ARRAY_LEN(AST_FORMAT_LIST); x++) {
 		if (all || 
 			  !strcasecmp(AST_FORMAT_LIST[x].name,name) ||
 			  !strcasecmp(AST_FORMAT_LIST[x].name, ast_expand_codec_alias(name))) {
@@ -590,7 +590,7 @@
 {
 	int x;
 	char *ret = "unknown";
-	for (x = 0; x < sizeof(AST_FORMAT_LIST) / sizeof(AST_FORMAT_LIST[0]); x++) {
+	for (x = 0; x < ARRAY_LEN(AST_FORMAT_LIST); x++) {
 		if (AST_FORMAT_LIST[x].bits == codec) {
 			ret = AST_FORMAT_LIST[x].desc;
 			break;
@@ -1023,7 +1023,7 @@
 	memcpy(&oldorder, pref, sizeof(oldorder));
 	memset(pref, 0, sizeof(*pref));
 
-	for (x = 0; x < sizeof(AST_FORMAT_LIST) / sizeof(AST_FORMAT_LIST[0]); x++) {
+	for (x = 0; x < ARRAY_LEN(AST_FORMAT_LIST); x++) {
 		slot = oldorder.order[x];
 		size = oldorder.framing[x];
 		if (! slot)
@@ -1043,7 +1043,7 @@
 
 	ast_codec_pref_remove(pref, format);
 
-	for (x = 0; x < sizeof(AST_FORMAT_LIST) / sizeof(AST_FORMAT_LIST[0]); x++) {
+	for (x = 0; x < ARRAY_LEN(AST_FORMAT_LIST); x++) {
 		if (AST_FORMAT_LIST[x].bits == format) {
 			newindex = x + 1;
 			break;
@@ -1051,7 +1051,7 @@
 	}
 
 	if (newindex) {
-		for (x = 0; x < sizeof(AST_FORMAT_LIST) / sizeof(AST_FORMAT_LIST[0]); x++) {
+		for (x = 0; x < ARRAY_LEN(AST_FORMAT_LIST); x++) {
 			if (!pref->order[x]) {
 				pref->order[x] = newindex;
 				break;
@@ -1104,7 +1104,7 @@
 {
 	int x, index = -1;
 
-	for (x = 0; x < sizeof(AST_FORMAT_LIST) / sizeof(AST_FORMAT_LIST[0]); x++) {
+	for (x = 0; x < ARRAY_LEN(AST_FORMAT_LIST); x++) {
 		if (AST_FORMAT_LIST[x].bits == format) {
 			index = x;
 			break;
@@ -1128,7 +1128,7 @@
 		framems = AST_FORMAT_LIST[index].max_ms;
 
 
-	for (x = 0; x < sizeof(AST_FORMAT_LIST) / sizeof(AST_FORMAT_LIST[0]); x++) {
+	for (x = 0; x < ARRAY_LEN(AST_FORMAT_LIST); x++) {
 		if (pref->order[x] == (index + 1)) {
 			pref->framing[x] = framems;
 			break;
@@ -1144,7 +1144,7 @@
 	int x, index = -1, framems = 0;
 	struct ast_format_list fmt = { 0, };
 
-	for (x = 0; x < sizeof(AST_FORMAT_LIST) / sizeof(AST_FORMAT_LIST[0]); x++) {
+	for (x = 0; x < ARRAY_LEN(AST_FORMAT_LIST); x++) {
 		if (AST_FORMAT_LIST[x].bits == format) {
 			fmt = AST_FORMAT_LIST[x];
 			index = x;
@@ -1152,7 +1152,7 @@
 		}
 	}
 
-	for (x = 0; x < sizeof(AST_FORMAT_LIST) / sizeof(AST_FORMAT_LIST[0]); x++) {
+	for (x = 0; x < ARRAY_LEN(AST_FORMAT_LIST); x++) {
 		if (pref->order[x] == (index + 1)) {
 			framems = pref->framing[x];
 			break;
@@ -1182,7 +1182,7 @@
 {
 	int x, ret = 0, slot;
 
-	for (x = 0; x < sizeof(AST_FORMAT_LIST) / sizeof(AST_FORMAT_LIST[0]); x++) {
+	for (x = 0; x < ARRAY_LEN(AST_FORMAT_LIST); x++) {
 		slot = pref->order[x];
 
 		if (!slot)
Index: main/logger.c
===================================================================
--- main/logger.c	(revision 128490)
+++ main/logger.c	(working copy)
@@ -530,7 +530,7 @@
 		/* Find the next empty slot, including a possible suffix */
 		for (x = 0; ; x++) {
 			found = 0;
-			for (which = 0; which < sizeof(suffixes) / sizeof(suffixes[0]); which++) {
+			for (which = 0; which < ARRAY_LEN(suffixes); which++) {
 				snprintf(new, sizeof(new), "%s.%d%s", filename, x, suffixes[which]);
 				fd = open(new, O_RDONLY);
 				if (fd > -1)
@@ -546,7 +546,7 @@
 
 		/* Found an empty slot */
 		for (y = x; y > -1; y--) {
-			for (which = 0; which < sizeof(suffixes) / sizeof(suffixes[0]); which++) {
+			for (which = 0; which < ARRAY_LEN(suffixes); which++) {
 				snprintf(old, sizeof(old), "%s.%d%s", filename, y - 1, suffixes[which]);
 				fd = open(old, O_RDONLY);
 				if (fd > -1) {
Index: main/pbx.c
===================================================================
--- main/pbx.c	(revision 128490)
+++ main/pbx.c	(working copy)
@@ -2320,7 +2320,7 @@
 		}
 	}
 	/* if not found, look into chanvars or global vars */
-	for (i = 0; s == &not_found && i < (sizeof(places) / sizeof(places[0])); i++) {
+	for (i = 0; s == &not_found && i < ARRAY_LEN(places); i++) {
 		struct ast_var_t *variables;
 		if (!places[i])
 			continue;
@@ -3098,7 +3098,7 @@
 {
 	int i;
 
-	for (i = 0; (i < (sizeof(extension_states) / sizeof(extension_states[0]))); i++) {
+	for (i = 0; (i < ARRAY_LEN(extension_states)); i++) {
 		if (extension_states[i].extension_state == extension_state)
 			return extension_states[i].text;
 	}
Index: main/callerid.c
===================================================================
--- main/callerid.c	(revision 128490)
+++ main/callerid.c	(working copy)
@@ -1099,7 +1099,7 @@
 {
 	int i;
 
-	for (i = 0; i < ((sizeof(pres_types) / sizeof(pres_types[0]))); i++) {
+	for (i = 0; i < ARRAY_LEN(pres_types); i++) {
 		if (!strcasecmp(pres_types[i].name, data))
 			return pres_types[i].val;
 	}
@@ -1115,7 +1115,7 @@
 {
 	int i;
 
-	for (i = 0; i < ((sizeof(pres_types) / sizeof(pres_types[0]))); i++) {
+	for (i = 0; i < ARRAY_LEN(pres_types); i++) {
 		if (pres_types[i].val == data)
 			return pres_types[i].description;
 	}
@@ -1131,7 +1131,7 @@
 {
 	int i;
 
-	for (i = 0; i < ((sizeof(pres_types) / sizeof(pres_types[0]))); i++) {
+	for (i = 0; i < ARRAY_LEN(pres_types); i++) {
 		if (pres_types[i].val == data)
 			return pres_types[i].name;
 	}
Index: res/res_limit.c
===================================================================
--- res/res_limit.c	(revision 128490)
+++ res/res_limit.c	(working copy)
@@ -66,7 +66,7 @@
 static int str2limit(const char *string)
 {
 	size_t i;
-	for (i = 0; i < sizeof(limits) / sizeof(limits[0]); i++) {
+	for (i = 0; i < ARRAY_LEN(limits); i++) {
 		if (!strcasecmp(string, limits[i].limit))
 			return limits[i].resource;
 	}
@@ -76,7 +76,7 @@
 static const char *str2desc(const char *string)
 {
 	size_t i;
-	for (i = 0; i < sizeof(limits) / sizeof(limits[0]); i++) {
+	for (i = 0; i < ARRAY_LEN(limits); i++) {
 		if (!strcmp(string, limits[i].limit))
 			return limits[i].desc;
 	}
@@ -90,7 +90,7 @@
 
 	if (a->pos > 1)
 		return NULL;
-	for (i = 0; i < sizeof(limits) / sizeof(limits[0]); i++) {
+	for (i = 0; i < ARRAY_LEN(limits); i++) {
 		if (!strncasecmp(limits[i].limit, a->word, wordlen)) {
 			if (++which > a->n)
 				return ast_strdup(limits[i].limit);
@@ -154,7 +154,7 @@
 	if (a->argc == 1) {
 		char arg2[3];
 		char *newargv[2] = { "ulimit", arg2 };
-		for (resource = 0; resource < sizeof(limits) / sizeof(limits[0]); resource++) {
+		for (resource = 0; resource < ARRAY_LEN(limits); resource++) {
 			struct ast_cli_args newArgs = { .argv = newargv, .argc = 2 };
 			ast_copy_string(arg2, limits[resource].limit, sizeof(arg2));
 			handle_cli_ulimit(e, CLI_HANDLER, &newArgs);
Index: formats/format_pcm.c
===================================================================
--- formats/format_pcm.c	(revision 128490)
+++ formats/format_pcm.c	(working copy)
@@ -472,9 +472,9 @@
 	int index;
 
 	/* XXX better init ? */
-	for (index = 0; index < (sizeof(ulaw_silence) / sizeof(ulaw_silence[0])); index++)
+	for (index = 0; index < ARRAY_LEN(ulaw_silence); index++)
 		ulaw_silence[index] = AST_LIN2MU(0);
-	for (index = 0; index < (sizeof(alaw_silence) / sizeof(alaw_silence[0])); index++)
+	for (index = 0; index < ARRAY_LEN(alaw_silence); index++)
 		alaw_silence[index] = AST_LIN2A(0);
 
 	if ( ast_format_register(&pcm_f)
