include: misc: util.h: Rename min/max to MIN/MAX

There are issues using lowercase min and max macros when compiling a C++
application with a third-party toolchain such as GNU ARM Embedded when
using some STL headers i.e. <chrono>.

This is because there are actual C++ functions called min and max
defined in some of the STL headers and these macros interfere with them.
By changing the macros to UPPERCASE, which is consistent with almost all
other pre-processor macros this naming conflict is avoided.

All files that use these macros have been updated.

Signed-off-by: Carlos Stuart <[email protected]>

Author: carlos-stuart

boards/posix/native_posix/main.c

@@ -36,7 +36,7 @@ void posix_exit(int exit_code)
 {
 	static int max_exit_code;
 
-	max_exit_code = max(exit_code, max_exit_code);
+	max_exit_code = MAX(exit_code, max_exit_code);
 	/*
 	 * posix_soc_clean_up may not return if this is called from a SW thread,
 	 * but instead it would get posix_exit() recalled again

boards/posix/native_posix/timer_model.c

@@ -126,7 +126,7 @@ void hwtimer_set_real_time_mode(bool new_rt)
 
 static void hwtimer_update_timer(void)
 {
-	hw_timer_timer = min(hw_timer_tick_timer, hw_timer_awake_timer);
+	hw_timer_timer = MIN(hw_timer_tick_timer, hw_timer_awake_timer);
 }
 
 static inline void host_clock_gettime(struct timespec *tv)

drivers/bluetooth/hci/h4.c

@@ -232,7 +232,7 @@ static size_t h4_discard(struct device *uart, size_t len)
 {
 	u8_t buf[33];
 
-	return uart_fifo_read(uart, buf, min(len, sizeof(buf)));
+	return uart_fifo_read(uart, buf, MIN(len, sizeof(buf)));
 }
 
 static inline void read_payload(void)

drivers/entropy/entropy_sam.c

@@ -58,7 +58,7 @@ static int entropy_sam_get_entropy(struct device *dev, u8_t *buffer,
 		}
 
 		value = trng->TRNG_ODATA;
-		to_copy = min(length, sizeof(value));
+		to_copy = MIN(length, sizeof(value));
 
 		memcpy(buffer, &value, to_copy);
 		buffer += to_copy;

drivers/entropy/fake_entropy_native_posix.c

@@ -35,7 +35,7 @@ static int entropy_native_posix_get_entropy(struct device *dev, u8_t *buffer,
 		 */
 		long int value = random();
 
-		size_t to_copy = min(length, sizeof(long int));
+		size_t to_copy = MIN(length, sizeof(long int));
 
 		memcpy(buffer, &value, to_copy);
 		buffer += to_copy;

drivers/flash/flash_sam.c

@@ -185,7 +185,7 @@ static int flash_sam_write(struct device *dev, off_t offset,
 
 		/* Maximum size without crossing a page */
 		eop_len = -(offset | ~(IFLASH_PAGE_SIZE - 1));
-		write_len = min(len, eop_len);
+		write_len = MIN(len, eop_len);
 
 		rc = flash_sam_write_page(dev, offset, data8, write_len);
 		if (rc < 0) {

drivers/flash/soc_flash_nios2_qspi.c

@@ -105,7 +105,7 @@ static int flash_nios2_qspi_erase(struct device *dev, off_t offset, size_t len)
 		}
 
 		/* calculate the byte size of data to be written in a sector */
-		length_to_erase = min(qspi_dev->sector_size - offset_in_block,
+		length_to_erase = MIN(qspi_dev->sector_size - offset_in_block,
 							remaining_length);
 
 		/* Erase sector */
@@ -297,7 +297,7 @@ static int flash_nios2_qspi_write(struct device *dev, off_t offset,
 		}
 
 		/* calculate the byte size of data to be written in a sector */
-		length_to_write = min(qspi_dev->sector_size - offset_in_block,
+		length_to_write = MIN(qspi_dev->sector_size - offset_in_block,
 							remaining_length);
 
 		rc = flash_nios2_qspi_write_block(dev,

drivers/i2c/i2c_dw.c

@@ -69,8 +69,8 @@ static inline void _i2c_dw_data_ask(struct device *dev)
 	tx_empty = I2C_DW_FIFO_DEPTH - regs->ic_txflr;
 
 	/* Figure out how many bytes we can request */
-	cnt = min(I2C_DW_FIFO_DEPTH, dw->request_bytes);
-	cnt = min(min(tx_empty, rx_empty), cnt);
+	cnt = MIN(I2C_DW_FIFO_DEPTH, dw->request_bytes);
+	cnt = MIN(MIN(tx_empty, rx_empty), cnt);
 
 	while (cnt > 0) {
 		/* Tell controller to get another byte */

drivers/i2c/i2c_esp32.c

@@ -388,7 +388,7 @@ static int i2c_esp32_read_msg(struct device *dev, u16_t addr,
 
 	for (; msg.len; cmd = (void *)I2C_COMD0_REG(config->index)) {
 		volatile struct i2c_esp32_cmd *wait_cmd = NULL;
-		u32_t to_read = min(I2C_ESP32_BUFFER_SIZE, msg.len - 1);
+		u32_t to_read = MIN(I2C_ESP32_BUFFER_SIZE, msg.len - 1);
 
 		/* Might be the last byte, in which case, `to_read` will
 		 * be 0 here.  See comment below.
@@ -464,7 +464,7 @@ static int i2c_esp32_write_msg(struct device *dev, u16_t addr,
 	cmd = i2c_esp32_write_addr(dev, cmd, &msg, addr);
 
 	for (; msg.len; cmd = (void *)I2C_COMD0_REG(config->index)) {
-		u32_t to_send = min(I2C_ESP32_BUFFER_SIZE, msg.len);
+		u32_t to_send = MIN(I2C_ESP32_BUFFER_SIZE, msg.len);
 		u32_t i;
 		int ret;
 

drivers/spi/spi_sam.c

@@ -92,7 +92,7 @@ static int spi_sam_configure(struct device *dev,
 
 	/* Use the requested or next higest possible frequency */
 	div = SOC_ATMEL_SAM_MCK_FREQ_HZ / config->frequency;
-	div = max(1, min(UINT8_MAX, div));
+	div = MAX(1, MIN(UINT8_MAX, div));
 	spi_csr |= SPI_CSR_SCBR(div);
 
 	regs->SPI_CR = SPI_CR_SPIDIS; /* Disable SPI */

drivers/spi/spi_sam0.c

@@ -95,7 +95,7 @@ static int spi_sam0_configure(struct device *dev,
 
 	/* Use the requested or next higest possible frequency */
 	div = (SOC_ATMEL_SAM0_GCLK0_FREQ_HZ / config->frequency) / 2 - 1;
-	div = max(0, min(UINT8_MAX, div));
+	div = MAX(0, MIN(UINT8_MAX, div));
 
 	/* Update the configuration only if it has changed */
 	if (regs->CTRLA.reg != ctrla.reg || regs->CTRLB.reg != ctrlb.reg ||

drivers/timer/arcv2_timer0.c

@@ -194,7 +194,7 @@ void z_clock_set_timeout(s32_t ticks, bool idle)
 #if defined(CONFIG_TICKLESS_KERNEL)
 	u32_t delay;
 
-	ticks = min(MAX_TICKS, max(ticks - 1, 0));
+	ticks = MIN(MAX_TICKS, MAX(ticks - 1, 0));
 
 	/* Desired delay in the future */
 	delay = (ticks == 0) ? MIN_DELAY : ticks * CYC_PER_TICK;

drivers/timer/cortex_m_systick.c

@@ -93,7 +93,7 @@ void z_clock_set_timeout(s32_t ticks, bool idle)
 #if defined(CONFIG_TICKLESS_KERNEL) && !defined(CONFIG_QEMU_TICKLESS_WORKAROUND)
 	u32_t delay;
 
-	ticks = min(MAX_TICKS, max(ticks - 1, 0));
+	ticks = MIN(MAX_TICKS, MAX(ticks - 1, 0));
 
 	/* Desired delay in the future */
 	delay = (ticks == 0) ? MIN_DELAY : ticks * CYC_PER_TICK;

drivers/timer/hpet.c

@@ -109,7 +109,7 @@ void z_clock_set_timeout(s32_t ticks, bool idle)
 	}
 
 	ticks = ticks == K_FOREVER ? max_ticks : ticks;
-	ticks = max(min(ticks - 1, (s32_t)max_ticks), 0);
+	ticks = MAX(MIN(ticks - 1, (s32_t)max_ticks), 0);
 
 	k_spinlock_key_t key = k_spin_lock(&lock);
 	u32_t now = MAIN_COUNTER_REG, cyc;

drivers/timer/nrf_rtc_timer.c

@@ -128,15 +128,15 @@ void z_clock_set_timeout(s32_t ticks, bool idle)
 
 #ifdef CONFIG_TICKLESS_KERNEL
 	ticks = (ticks == K_FOREVER) ? MAX_TICKS : ticks;
-	ticks = max(min(ticks - 1, (s32_t)MAX_TICKS), 0);
+	ticks = MAX(MIN(ticks - 1, (s32_t)MAX_TICKS), 0);
 
 	/*
 	 * Get the requested delay in tick-aligned cycles.  Increase
 	 * by one tick to round up so we don't timeout early due to
 	 * cycles elapsed since the last tick.  Cap at the maximum
 	 * tick-aligned delta.
 	 */
-	u32_t cyc = min((1 + ticks) * CYC_PER_TICK, MAX_DELAY);
+	u32_t cyc = MIN((1 + ticks) * CYC_PER_TICK, MAX_DELAY);
 
 	u32_t key = irq_lock();
 	u32_t d = counter_sub(counter(), last_count);

drivers/timer/riscv_machine_timer.c

@@ -95,7 +95,7 @@ void z_clock_set_timeout(s32_t ticks, bool idle)
 	}
 
 	ticks = ticks == K_FOREVER ? MAX_TICKS : ticks;
-	ticks = max(min(ticks - 1, (s32_t)MAX_TICKS), 0);
+	ticks = MAX(MIN(ticks - 1, (s32_t)MAX_TICKS), 0);
 
 	k_spinlock_key_t key = k_spin_lock(&lock);
 	u64_t now = mtime();

drivers/timer/sam0_rtc_timer.c

@@ -205,7 +205,7 @@ void z_clock_set_timeout(s32_t ticks, bool idle)
 #ifdef CONFIG_TICKLESS_KERNEL
 
 	ticks = (ticks == K_FOREVER) ? MAX_TICKS : ticks;
-	ticks = max(min(ticks - 1, (s32_t) MAX_TICKS), 0);
+	ticks = MAX(MIN(ticks - 1, (s32_t) MAX_TICKS), 0);
 
 	/* Compute number of RTC cycles until the next timeout. */
 	u32_t count = rtc_count();

drivers/timer/xtensa_sys_timer.c

@@ -82,7 +82,7 @@ void z_clock_set_timeout(s32_t ticks, bool idle)
 
 #if defined(CONFIG_TICKLESS_KERNEL) && !defined(CONFIG_QEMU_TICKLESS_WORKAROUND)
 	ticks = ticks == K_FOREVER ? MAX_TICKS : ticks;
-	ticks = max(min(ticks - 1, (s32_t)MAX_TICKS), 0);
+	ticks = MAX(MIN(ticks - 1, (s32_t)MAX_TICKS), 0);
 
 	k_spinlock_key_t key = k_spin_lock(&lock);
 	u32_t curr = ccount(), cyc;

drivers/usb/device/usb_dc_nrfx.c

@@ -1674,7 +1674,7 @@ int usb_dc_ep_read_wait(u8_t ep, u8_t *data, u32_t max_data_len,
 
 	k_mutex_lock(&ctx->drv_lock, K_FOREVER);
 
-	bytes_to_copy = min(max_data_len, ep_ctx->buf.len);
+	bytes_to_copy = MIN(max_data_len, ep_ctx->buf.len);
 
 	if (!data && !max_data_len) {
 		if (read_bytes) {

drivers/usb/device/usb_dc_sam.c

@@ -475,7 +475,7 @@ int usb_dc_ep_configure(const struct usb_dc_ep_cfg_data *const cfg)
 	 * Map the endpoint size to the buffer size. Only power of 2 buffer
 	 * sizes between 8 and 1024 are possible, get the next power of 2.
 	 */
-	log2ceil_mps = 32 - __builtin_clz((max(cfg->ep_mps, 8) << 1) - 1) - 1;
+	log2ceil_mps = 32 - __builtin_clz((MAX(cfg->ep_mps, 8) << 1) - 1) - 1;
 	regval |= USBHS_DEVEPTCFG_EPSIZE(log2ceil_mps - 3);
 	dev_data.ep_data[ep_idx].mps = cfg->ep_mps;
 
@@ -695,7 +695,7 @@ int usb_dc_ep_write(u8_t ep, const u8_t *data, u32_t data_len, u32_t *ret_bytes)
 	}
 
 	/* Write the data to the FIFO */
-	packet_len = min(data_len, dev_data.ep_data[ep_idx].mps);
+	packet_len = MIN(data_len, dev_data.ep_data[ep_idx].mps);
 	for (int i = 0; i < packet_len; i++) {
 		usb_dc_ep_fifo_put(ep_idx, data[i]);
 	}

drivers/usb/device/usb_dc_sam0.c

@@ -490,7 +490,7 @@ int usb_dc_ep_read_ex(u8_t ep, u8_t *buf, u32_t max_data_len,
 	}
 
 	remain = bytes - data->out_at;
-	take = min(max_data_len, remain);
+	take = MIN(max_data_len, remain);
 	memcpy(buf, (u8_t *)addr + data->out_at, take);
 
 	if (read_bytes != NULL) {

drivers/usb/device/usb_dc_stm32.c

@@ -797,7 +797,7 @@ int usb_dc_ep_read_wait(u8_t ep, u8_t *data, u32_t max_data_len,
 	 * previously stored in the buffer.
 	 */
 	if (data) {
-		read_count = min(read_count, max_data_len);
+		read_count = MIN(read_count, max_data_len);
 		memcpy(data, usb_dc_stm32_state.ep_buf[EP_IDX(ep)] +
 		       ep_state->read_offset, read_count);
 		ep_state->read_count -= read_count;

drivers/wifi/eswifi/eswifi_bus_spi.c

@@ -159,7 +159,7 @@ static int eswifi_spi_request(struct eswifi_dev *eswifi, char *cmd, size_t clen,
 	}
 
 	while (eswifi_spi_cmddata_ready(spi) && to_read) {
-		to_read = min(rlen - offset, to_read);
+		to_read = MIN(rlen - offset, to_read);
 		memset(rsp + offset, 0, to_read);
 		eswifi_spi_read(eswifi, rsp + offset, to_read);
 		offset += to_read;

ext/lib/mgmt/mcumgr/cmd/log_mgmt/port/zephyr/src/zephyr_log_mgmt.c

@@ -121,7 +121,7 @@ zephyr_log_mgmt_walk_cb(struct mdlog *log, struct mdlog_offset *log_offset,
         return 0;
     }
 
-    read_len = min(len - sizeof ueh, LOG_MGMT_BODY_LEN - sizeof ueh);
+    read_len = MIN(len - sizeof ueh, LOG_MGMT_BODY_LEN - sizeof ueh);
     rc = mdlog_read(log, desciptor, zephyr_log_mgmt_walk_arg->body, sizeof ueh,
                     read_len);
     if (rc < 0) {

include/arch/arc/arch.h

@@ -68,7 +68,7 @@ extern "C" {
 	#define STACK_GUARD_SIZE 0
 #endif /* CONFIG_MPU_STACK_GUARD */
 
-#define STACK_SIZE_ALIGN(x)	max(STACK_ALIGN, x)
+#define STACK_SIZE_ALIGN(x)	MAX(STACK_ALIGN, x)
 
 
 /**
@@ -91,7 +91,7 @@ extern "C" {
 
 #define _ARCH_THREAD_STACK_LEN(size) \
 	    (POW2_CEIL(STACK_SIZE_ALIGN(size)) + \
-	     max(POW2_CEIL(STACK_SIZE_ALIGN(size)), \
+	     MAX(POW2_CEIL(STACK_SIZE_ALIGN(size)), \
 		 POW2_CEIL(STACK_GUARD_SIZE + CONFIG_PRIVILEGED_STACK_SIZE)))
 
 #define _ARCH_THREAD_STACK_ARRAY_DEFINE(sym, nmemb, size) \

include/arch/arm/arch.h

@@ -109,7 +109,7 @@ extern "C" {
 #if defined(CONFIG_USERSPACE)
 #define STACK_ALIGN    CONFIG_ARM_MPU_REGION_MIN_ALIGN_AND_SIZE
 #else
-#define STACK_ALIGN    max(STACK_ALIGN_SIZE, MPU_GUARD_ALIGN_AND_SIZE)
+#define STACK_ALIGN    MAX(STACK_ALIGN_SIZE, MPU_GUARD_ALIGN_AND_SIZE)
 #endif
 
 /**

include/arch/x86/arch.h

@@ -613,7 +613,7 @@ extern struct task_state_segment _main_tss;
 
 #define _ARCH_THREAD_STACK_LEN(size) \
 		(ROUND_UP((size), \
-			  max(_STACK_BASE_ALIGN, _STACK_SIZE_ALIGN)) + \
+			  MAX(_STACK_BASE_ALIGN, _STACK_SIZE_ALIGN)) + \
 		_STACK_GUARD_SIZE)
 
 #define _ARCH_THREAD_STACK_ARRAY_DEFINE(sym, nmemb, size) \

include/misc/util.h

@@ -86,12 +86,12 @@ constexpr size_t ARRAY_SIZE(T(&)[N]) { return N; }
 #define INLINE
 #endif
 
-#ifndef max
-#define max(a, b) (((a) > (b)) ? (a) : (b))
+#ifndef MAX
+#define MAX(a, b) (((a) > (b)) ? (a) : (b))
 #endif
 
-#ifndef min
-#define min(a, b) (((a) < (b)) ? (a) : (b))
+#ifndef MIN
+#define MIN(a, b) (((a) < (b)) ? (a) : (b))
 #endif
 
 static inline int is_power_of_two(unsigned int x)

include/net/lldp.h

@@ -95,7 +95,7 @@ extern "C" {
  * to zero so LLDP Rx agents can invalidate the entry related to this node.
  */
 #define NET_LLDP_TTL \
-	min((CONFIG_NET_LLDP_TX_INTERVAL * CONFIG_NET_LLDP_TX_HOLD) + 1, 65535)
+	MIN((CONFIG_NET_LLDP_TX_INTERVAL * CONFIG_NET_LLDP_TX_HOLD) + 1, 65535)
 
 
 struct net_if;

kernel/pipes.c

@@ -197,7 +197,7 @@ void k_pipe_cleanup(struct k_pipe *pipe)
 static size_t pipe_xfer(unsigned char *dest, size_t dest_size,
 			 const unsigned char *src, size_t src_size)
 {
-	size_t num_bytes = min(dest_size, src_size);
+	size_t num_bytes = MIN(dest_size, src_size);
 	const unsigned char *end = src + num_bytes;
 
 	while (src != end) {
@@ -227,7 +227,7 @@ static size_t pipe_buffer_put(struct k_pipe *pipe,
 
 
 	for (i = 0; i < 2; i++) {
-		run_length = min(pipe->size - pipe->bytes_used,
+		run_length = MIN(pipe->size - pipe->bytes_used,
 				 pipe->size - pipe->write_index);
 
 		bytes_copied = pipe_xfer(pipe->buffer + pipe->write_index,
@@ -263,7 +263,7 @@ static size_t pipe_buffer_get(struct k_pipe *pipe,
 	int     i;
 
 	for (i = 0; i < 2; i++) {
-		run_length = min(pipe->bytes_used,
+		run_length = MIN(pipe->bytes_used,
 				 pipe->size - pipe->read_index);
 
 		bytes_copied = pipe_xfer(dest + num_bytes_read,

kernel/timeout.c

@@ -62,7 +62,7 @@ static s32_t next_timeout(void)
 {
 	int maxw = can_wait_forever ? K_FOREVER : INT_MAX;
 	struct _timeout *to = first();
-	s32_t ret = to == NULL ? maxw : max(0, to->dticks - elapsed());
+	s32_t ret = to == NULL ? maxw : MAX(0, to->dticks - elapsed());
 
 #ifdef CONFIG_TIMESLICING
 	if (_current_cpu->slice_ticks && _current_cpu->slice_ticks < ret) {
@@ -76,7 +76,7 @@ void _add_timeout(struct _timeout *to, _timeout_func_t fn, s32_t ticks)
 {
 	__ASSERT(!sys_dnode_is_linked(&to->node), "");
 	to->fn = fn;
-	ticks = max(1, ticks);
+	ticks = MAX(1, ticks);
 
 	LOCKED(&timeout_lock) {
 		struct _timeout *t;

lib/os/ring_buffer.c

@@ -114,11 +114,11 @@ u32_t ring_buf_put_claim(struct ring_buf *buf, u8_t **data, u32_t size)
 					    buf->misc.byte_mode.tmp_tail);
 
 	/* Limit requested size to available size. */
-	size = min(size, space);
+	size = MIN(size, space);
 	trail_size = buf->size - buf->misc.byte_mode.tmp_tail;
 
 	/* Limit allocated size to trail size. */
-	allocated = min(trail_size, size);
+	allocated = MIN(trail_size, size);
 
 	*data = &buf->buf.buf8[buf->misc.byte_mode.tmp_tail];
 	buf->misc.byte_mode.tmp_tail =
@@ -169,10 +169,10 @@ u32_t ring_buf_get_claim(struct ring_buf *buf, u8_t **data, u32_t size)
 	trail_size = buf->size - buf->misc.byte_mode.tmp_head;
 
 	/* Limit requested size to available size. */
-	granted_size = min(size, space);
+	granted_size = MIN(size, space);
 
 	/* Limit allocated size to trail size. */
-	granted_size = min(trail_size, granted_size);
+	granted_size = MIN(trail_size, granted_size);
 
 	*data = &buf->buf.buf8[buf->misc.byte_mode.tmp_head];
 	buf->misc.byte_mode.tmp_head =

samples/bluetooth/eddystone/src/main.c

@@ -487,7 +487,7 @@ static ssize_t write_adv_data(struct bt_conn *conn,
 		 * controlled by characteristics 4 (Radio Tx Power) and
 		 * 5 (Advertised Tx Power).
 		 */
-		slot->ad[2].data_len = min(slot->ad[2].data_len,
+		slot->ad[2].data_len = MIN(slot->ad[2].data_len,
 					   len + EDS_URL_WRITE_OFFSET);
 		memcpy(&slot->ad[2].data + EDS_URL_WRITE_OFFSET, buf,
 		       slot->ad[2].data_len - EDS_URL_WRITE_OFFSET);