Replace ARRAY_SIZE with boost::size where possible

Remaining uses need a constexpr value.

src/cli/debug.cpp

@@ -24,6 +24,7 @@
 #include <iostream>
 
 #include <boost/foreach.hpp>
+#include <boost/range/size.hpp>
 
 #include "loader/offsets.hpp"
 #include "setup/component.hpp"
@@ -49,7 +50,6 @@
 #include "util/log.hpp"
 #include "util/output.hpp"
 #include "util/time.hpp"
-#include "util/util.hpp"
 
 void print_offsets(const loader::offsets & offsets) {
 	
@@ -524,7 +524,7 @@ static const char * magic_numbers[][2] = {
 
 static const char * guess_extension(const std::string & data) {
 	
-	for(size_t i = 0; i < ARRAY_SIZE(magic_numbers); i++) {
+	for(size_t i = 0; i < boost::size(magic_numbers); i++) {
 		
 		size_t n = strlen(magic_numbers[i][0]);
 		

src/cli/main.cpp

@@ -28,14 +28,15 @@
 #include <string>
 #include <vector>
 
-#include <boost/algorithm/string/predicate.hpp>
 #include <boost/foreach.hpp>
 #include <boost/make_shared.hpp>
 #include <boost/program_options.hpp>
 #include <boost/scoped_ptr.hpp>
-#include <boost/ptr_container/ptr_vector.hpp>
+#include <boost/algorithm/string/predicate.hpp>
 #include <boost/filesystem/path.hpp>
 #include <boost/filesystem/operations.hpp>
+#include <boost/ptr_container/ptr_vector.hpp>
+#include <boost/range/size.hpp>
 
 #include "release.hpp"
 
@@ -403,7 +404,7 @@ static void process_file(const fs::path & file, const options & o) {
 			// Copy data
 			while(!file_source->eof()) {
 				char buffer[8192 * 10];
-				std::streamsize buffer_size = std::streamsize(ARRAY_SIZE(buffer));
+				std::streamsize buffer_size = std::streamsize(boost::size(buffer));
 				std::streamsize n = file_source->read(buffer, buffer_size).gcount();
 				if(n > 0) {
 					BOOST_FOREACH(file_output & out, output) {

src/crypto/checksum.cpp

@@ -25,6 +25,8 @@
 #include <ostream>
 #include <iomanip>
 
+#include <boost/range/size.hpp>
+
 namespace crypto {
 
 bool checksum::operator==(const checksum & o) const {
@@ -36,8 +38,8 @@ bool checksum::operator==(const checksum & o) const {
 	switch(type) {
 		case Adler32: return (adler32 == o.adler32);
 		case CRC32: return (crc32 == o.crc32);
-		case MD5: return !memcmp(md5, o.md5, ARRAY_SIZE(md5));
-		case SHA1: return !memcmp(sha1, o.sha1, ARRAY_SIZE(sha1));
+		case MD5: return !memcmp(md5, o.md5, boost::size(md5));
+		case SHA1: return !memcmp(sha1, o.sha1, boost::size(sha1));
 		default: return false;
 	};
 }
@@ -67,13 +69,13 @@ std::ostream & operator<<(std::ostream & os, const crypto::checksum & checksum)
 			break;
 		}
 		case crypto::MD5: {
-			for(size_t i = 0; i < ARRAY_SIZE(checksum.md5); i++) {
+			for(size_t i = 0; i < boost::size(checksum.md5); i++) {
 				os << std::setfill('0') << std::hex << std::setw(2) << int(boost::uint8_t(checksum.md5[i]));
 			}
 			break;
 		}
 		case crypto::SHA1: {
-			for(size_t i = 0; i < ARRAY_SIZE(checksum.sha1); i++) {
+			for(size_t i = 0; i < boost::size(checksum.sha1); i++) {
 				os << std::setfill('0') << std::hex << std::setw(2) << int(boost::uint8_t(checksum.sha1[i]));
 			}
 			break;

src/crypto/iteratedhash.hpp

@@ -26,6 +26,7 @@
 #include <cstring>
 
 #include <boost/cstdint.hpp>
+#include <boost/range/size.hpp>
 
 #include "crypto/checksum.hpp"
 #include "util/endian.hpp"
@@ -125,7 +126,7 @@ size_t iterated_hash<T>::hash(const char * input, size_t length) {
 		do {
 			
 			hash_word buffer[block_size / sizeof(hash_word)];
-			byte_order::load(input, buffer, ARRAY_SIZE(buffer));
+			byte_order::load(input, buffer, boost::size(buffer));
 			
 			transform::transform(state, buffer);
 			

src/loader/offsets.cpp

@@ -24,6 +24,7 @@
 
 #include <boost/cstdint.hpp>
 #include <boost/static_assert.hpp>
+#include <boost/range/size.hpp>
 
 #include <stddef.h>
 
@@ -101,16 +102,16 @@ bool offsets::load_offsets_at(std::istream & is, boost::uint32_t pos) {
 	}
 	
 	char magic[12];
-	if(is.read(magic, std::streamsize(ARRAY_SIZE(magic))).fail()) {
+	if(is.read(magic, std::streamsize(boost::size(magic))).fail()) {
 		is.clear();
 		return false;
 	}
 	
 	setup::version_constant version = 0;
-	for(size_t i = 0; i < ARRAY_SIZE(known_setup_loader_versions); i++) {
+	for(size_t i = 0; i < boost::size(known_setup_loader_versions); i++) {
 		BOOST_STATIC_ASSERT(ARRAY_SIZE(known_setup_loader_versions[i].magic)
 		                    == ARRAY_SIZE(magic));
-		if(!memcmp(magic, known_setup_loader_versions[i].magic, ARRAY_SIZE(magic))) {
+		if(!memcmp(magic, known_setup_loader_versions[i].magic, boost::size(magic))) {
 			version = known_setup_loader_versions[i].version;
 			break;
 		}
@@ -121,7 +122,7 @@ bool offsets::load_offsets_at(std::istream & is, boost::uint32_t pos) {
 	
 	crypto::crc32 checksum;
 	checksum.init();
-	checksum.update(magic, ARRAY_SIZE(magic));
+	checksum.update(magic, boost::size(magic));
 	
 	if(version >= INNO_VERSION(5, 1,  5)) {
 		boost::uint32_t revision = checksum.load<boost::uint32_t>(is);

src/setup/version.cpp

@@ -28,8 +28,8 @@
 #include <boost/version.hpp>
 #include <boost/static_assert.hpp>
 #include <boost/lexical_cast.hpp>
+#include <boost/range/size.hpp>
 
-#include "util/util.hpp"
 #include "util/log.hpp"
 
 namespace setup {
@@ -184,7 +184,7 @@ void version::load(std::istream & is) {
 	
 	if(legacy_version[0] == 'i' && legacy_version[sizeof(legacy_version) - 1] == '\x1a') {
 		
-		for(size_t i = 0; i < ARRAY_SIZE(legacy_versions); i++) {
+		for(size_t i = 0; i < boost::size(legacy_versions); i++) {
 			if(!memcmp(legacy_version, legacy_versions[i].name, sizeof(legacy_version))) {
 				value = legacy_versions[i].version;
 				bits = legacy_versions[i].bits;
@@ -196,7 +196,7 @@ void version::load(std::istream & is) {
 		}
 		
 		debug("unknown legacy version: \""
-		      << std::string(legacy_version, ARRAY_SIZE(legacy_version)) << '"');
+		      << std::string(legacy_version, boost::size(legacy_version)) << '"');
 		
 		if(legacy_version[0] != 'i' || legacy_version[2] != '.' || legacy_version[4] != '.'
 		   || legacy_version[7] != '-' || legacy_version[8] != '-') {
@@ -211,7 +211,7 @@ void version::load(std::istream & is) {
 			throw version_error();
 		}
 		
-		std::string version_str(legacy_version, legacy_version + ARRAY_SIZE(legacy_version));
+		std::string version_str(legacy_version, legacy_version + boost::size(legacy_version));
 		
 		try {
 			unsigned a = to_unsigned(version_str.data() + 1, 1);
@@ -234,7 +234,7 @@ void version::load(std::istream & is) {
 	        std::streamsize(sizeof(version) - sizeof(legacy_version)));
 	
 	
-	for(size_t i = 0; i < ARRAY_SIZE(versions); i++) {
+	for(size_t i = 0; i < boost::size(versions); i++) {
 		if(!memcmp(version, versions[i].name, sizeof(version))) {
 			value = versions[i].version;
 			bits = 32;
@@ -245,7 +245,7 @@ void version::load(std::istream & is) {
 		}
 	}
 	
-	char * end = std::find(version, version + ARRAY_SIZE(version), '\0');
+	char * end = std::find(version, version + boost::size(version), '\0');
 	std::string version_str(version, end);
 	debug("unknown version: \"" << version_str << '"');
 	if(version_str.find("Inno Setup") == std::string::npos) {
@@ -337,14 +337,14 @@ bool version::is_ambiguous() const {
 
 version_constant version::next() {
 	
-	const known_legacy_version * legacy_end = legacy_versions + ARRAY_SIZE(legacy_versions);
+	const known_legacy_version * legacy_end = legacy_versions + boost::size(legacy_versions);
 	const known_legacy_version * legacy_version;
 	legacy_version = std::upper_bound(legacy_versions, legacy_end, value);
 	if(legacy_version != legacy_end) {
 		return value = legacy_version->version;
 	}
 	
-	const known_version * end = versions + ARRAY_SIZE(versions);
+	const known_version * end = versions + boost::size(versions);
 	const known_version * version = std::upper_bound(versions, end, value);
 	if(version != end) {
 		return version->version;

src/setup/windows.cpp

@@ -23,10 +23,10 @@
 #include <ostream>
 
 #include <boost/cstdint.hpp>
+#include <boost/range/size.hpp>
 
 #include "setup/version.hpp"
 #include "util/load.hpp"
-#include "util/util.hpp"
 
 namespace setup {
 
@@ -103,9 +103,9 @@ const char * get_version_name(const windows_version::data & version, bool nt = f
 	windows_version_name * names;
 	size_t count;
 	if(nt) {
-		names = windows_nt_version_names, count = ARRAY_SIZE(windows_nt_version_names);
+		names = windows_nt_version_names, count = boost::size(windows_nt_version_names);
 	} else {
-		names = windows_version_names, count = ARRAY_SIZE(windows_version_names);
+		names = windows_version_names, count = boost::size(windows_version_names);
 	}
 	
 	for(size_t i = 0; i < count; i++) {

src/stream/chunk.cpp

@@ -23,6 +23,7 @@
 #include <boost/iostreams/filter/bzip2.hpp>
 #include <boost/iostreams/filter/zlib.hpp>
 #include <boost/make_shared.hpp>
+#include <boost/range/size.hpp>
 
 #include "release.hpp"
 #include "stream/lzma.hpp"
@@ -69,7 +70,7 @@ chunk_reader::pointer chunk_reader::get(slice_reader & base, const chunk & chunk
 	}
 	
 	char magic[ARRAY_SIZE(chunk_id)];
-	if(base.read(magic, 4) != 4 || memcmp(magic, chunk_id, ARRAY_SIZE(chunk_id))) {
+	if(base.read(magic, 4) != 4 || memcmp(magic, chunk_id, boost::size(chunk_id))) {
 		throw chunk_error("bad chunk magic");
 	}
 	

src/stream/slice.cpp

@@ -25,11 +25,11 @@
 #include <limits>
 
 #include <boost/cstdint.hpp>
+#include <boost/range/size.hpp>
 
 #include "util/console.hpp"
 #include "util/load.hpp"
 #include "util/log.hpp"
-#include "util/util.hpp"
 
 namespace stream {
 
@@ -99,7 +99,7 @@ bool slice_reader::open_file(const path_type & file) {
 		throw slice_error("could not read slice magic number");
 	}
 	bool found = false;
-	for(size_t i = 0; ARRAY_SIZE(slice_ids); i++) {
+	for(size_t i = 0; boost::size(slice_ids); i++) {
 		if(!std::memcmp(magic, slice_ids[i], 8)) {
 			found = true;
 			break;

src/util/enum.hpp

@@ -24,11 +24,11 @@
 #include <stddef.h>
 #include <ostream>
 
+#include <boost/range/size.hpp>
 #include <boost/utility/enable_if.hpp>
 
 #include "util/console.hpp"
 #include "util/flags.hpp"
-#include "util/util.hpp"
 
 template <class Enum>
 struct get_enum {
@@ -66,7 +66,7 @@ struct enum_names {
 	const char * enum_names<get_enum<Enum>::type>::name = (Name); \
 	const char * enum_names<get_enum<Enum>::type>::names[] = { __VA_ARGS__ }; \
 	const size_t enum_names<get_enum<Enum>::type>::count \
-	 = ARRAY_SIZE(enum_names<get_enum<Enum>::type>::names);
+	 = boost::size(enum_names<get_enum<Enum>::type>::names);
 
 #define USE_ENUM_NAMES(Enum) \
 	(void)enum_names<get_enum<Enum>::type>::count; \

src/util/load.hpp

@@ -29,10 +29,10 @@
 #include <string>
 
 #include <boost/cstdint.hpp>
+#include <boost/range/size.hpp>
 
 #include "util/endian.hpp"
 #include "util/types.hpp"
-#include "util/util.hpp"
 
 namespace util {
 
@@ -191,7 +191,7 @@ template <class T>
 void discard(T & is, boost::uint64_t bytes) {
 	char buf[1024];
 	while(bytes) {
-		std::streamsize n = std::streamsize(std::min<boost::uint64_t>(bytes, ARRAY_SIZE(buf)));
+		std::streamsize n = std::streamsize(std::min<boost::uint64_t>(bytes, boost::size(buf)));
 		is.read(buf, n);
 		bytes -= boost::uint64_t(n);
 	}

src/util/output.hpp

@@ -28,9 +28,9 @@
 #include <string>
 
 #include <boost/cstdint.hpp>
+#include <boost/range/size.hpp>
 
 #include "util/console.hpp"
-#include "util/util.hpp"
 
 struct quoted {
 	
@@ -185,7 +185,7 @@ std::ostream & operator<<(std::ostream & os, const print_bytes<T> & s) {
 	
 	size_t i = 0;
 	
-	while(whole > 1024 && i < ARRAY_SIZE(byte_size_units) - 1) {
+	while(whole > 1024 && i < boost::size(byte_size_units) - 1) {
 		
 		frac = whole % 1024, whole /= 1024;
 		

src/util/storedenum.hpp

@@ -34,7 +34,6 @@
 #include "util/enum.hpp"
 #include "util/load.hpp"
 #include "util/log.hpp"
-#include "util/util.hpp"
 
 // Shared info for enums and flags
 #define STORED_MAP_HELPER(MapName, TypeRep, DefaultDecl, ...) \