!fixup: ringbuffer.h: name collides with RingBuffer.h in Windows

Author: kbumsik

cores/arduino/VirtIOSerial.cpp

@@ -26,21 +26,21 @@
 #include "openamp.h"
 #include "openamp_log.h"
 #include "wiring.h"
-#include "ringbuffer.h"
+#include "virtio_buffer.h"
 
 VirtIOSerial SerialVirtIO;
 void serialEventVirtIO() __attribute__((weak));
 
 static VIRT_UART_HandleTypeDef huart;
 static bool initialized = false;
 static bool first_message_discarded = false;
-static ringbuffer_t ring;
+static virtio_buffer_t ring;
 
 void rxCallback(VIRT_UART_HandleTypeDef *huart);
 
 void VirtIOSerial::begin(void)
 {
-  ringbuffer_init(&ring);
+  virtio_buffer_init(&ring);
   if (initialized) {
     return;
   }
@@ -72,13 +72,13 @@ void VirtIOSerial::begin(uint32_t /* baud_count */, uint8_t /* config */)
 void VirtIOSerial::end()
 {
   OPENAMP_DeInit();
-  ringbuffer_init(&ring);
+  virtio_buffer_init(&ring);
   initialized = false;
 }
 
 int VirtIOSerial::available(void)
 {
-  return ringbuffer_read_available(&ring);
+  return virtio_buffer_read_available(&ring);
 }
 
 int VirtIOSerial::availableForWrite()
@@ -90,9 +90,9 @@ int VirtIOSerial::availableForWrite()
 
 int VirtIOSerial::peek(void)
 {
-  if (ringbuffer_read_available(&ring) > 0) {
+  if (virtio_buffer_read_available(&ring) > 0) {
     uint8_t tmp;
-    ringbuffer_peek(&ring, &tmp, 1);
+    virtio_buffer_peek(&ring, &tmp, 1);
     return tmp;
   } else {
     return -1;
@@ -115,10 +115,10 @@ size_t VirtIOSerial::readBytes(char *buffer, size_t length)
   const size_t size = length;
   _startMillis = millis();
   while (length > 0 && (millis() - _startMillis < _timeout)) {
-    uint16_t prev_write_available = ringbuffer_write_available(&ring);
-    length -= ringbuffer_read(&ring, reinterpret_cast<uint8_t *>(buffer), length);
+    uint16_t prev_write_available = virtio_buffer_write_available(&ring);
+    length -= virtio_buffer_read(&ring, reinterpret_cast<uint8_t *>(buffer), length);
     if (prev_write_available < RPMSG_BUFFER_SIZE
-        && ringbuffer_write_available(&ring) >= RPMSG_BUFFER_SIZE) {
+        && virtio_buffer_write_available(&ring) >= RPMSG_BUFFER_SIZE) {
       MAILBOX_Notify_Rx_Buf_Free();
     }
   }
@@ -163,11 +163,11 @@ void rxCallback(VIRT_UART_HandleTypeDef *huart)
   }
 
   /* copy received msg in a variable to sent it back to master processor in main infinite loop*/
-  size_t size = min(huart->RxXferSize, ringbuffer_write_available(&ring));
+  size_t size = min(huart->RxXferSize, virtio_buffer_write_available(&ring));
   while (size > 0) {
-    size -= ringbuffer_write(&ring, huart->pRxBuffPtr, size);
+    size -= virtio_buffer_write(&ring, huart->pRxBuffPtr, size);
   }
-  if (ringbuffer_write_available(&ring) >= RPMSG_BUFFER_SIZE) {
+  if (virtio_buffer_write_available(&ring) >= RPMSG_BUFFER_SIZE) {
     MAILBOX_Notify_Rx_Buf_Free();
   }
 }

cores/arduino/stm32/virtio/ringbuffer.c renamed to cores/arduino/stm32/virtio/virtio_buffer.c

@@ -23,24 +23,24 @@
 #ifdef VIRTIOCON
 
 #include "virtio_config.h"
-#include "ringbuffer.h"
+#include "virtio_buffer.h"
 #include <string.h>
 #include "wiring.h"
 
-#define BUFFER_END (VIRTIO_RINGBUFFER_SIZE - 1)
+#define BUFFER_END (VIRTIO_BUFFER_SIZE - 1)
 
-static uint16_t read_tmp(ringbuffer_t *ring, uint8_t *dst, uint16_t size);
-static void read_commit(ringbuffer_t *ring);
-static void read_rollback(ringbuffer_t *ring);
+static uint16_t read_tmp(virtio_buffer_t *ring, uint8_t *dst, uint16_t size);
+static void read_commit(virtio_buffer_t *ring);
+static void read_rollback(virtio_buffer_t *ring);
 
-void ringbuffer_init(ringbuffer_t *ring)
+void virtio_buffer_init(virtio_buffer_t *ring)
 {
   ring->write = 0;
   ring->read = 0;
   ring->read_tmp = 0;
 }
 
-uint16_t ringbuffer_read_available(ringbuffer_t *ring)
+uint16_t virtio_buffer_read_available(virtio_buffer_t *ring)
 {
   // This will make the function safe when write openrations are done in interrupts
   volatile uint16_t write = ring->write;
@@ -51,7 +51,7 @@ uint16_t ringbuffer_read_available(ringbuffer_t *ring)
   return write - ring->read;
 }
 
-static uint16_t read_tmp(ringbuffer_t *ring, uint8_t *dst, uint16_t size)
+static uint16_t read_tmp(virtio_buffer_t *ring, uint8_t *dst, uint16_t size)
 {
   // This will make the function safe when write openrations are done in interrupts
   volatile uint16_t write = ring->write;
@@ -66,29 +66,29 @@ static uint16_t read_tmp(ringbuffer_t *ring, uint8_t *dst, uint16_t size)
   return size;
 }
 
-static void read_commit(ringbuffer_t *ring)
+static void read_commit(virtio_buffer_t *ring)
 {
   ring->read = ring->read_tmp;
 }
 
-static void read_rollback(ringbuffer_t *ring)
+static void read_rollback(virtio_buffer_t *ring)
 {
   ring->read_tmp = ring->read;
 }
 
-uint16_t ringbuffer_read(ringbuffer_t *ring, uint8_t *dst, uint16_t size)
+uint16_t virtio_buffer_read(virtio_buffer_t *ring, uint8_t *dst, uint16_t size)
 {
   uint16_t recv_size = read_tmp(ring, dst, size);
   read_commit(ring);
   return recv_size;
 }
 
 /**
- * WARNING: The size of read cannot be larger than ringbuffer_read_available().
+ * WARNING: The size of read cannot be larger than virtio_buffer_read_available().
  */
-uint16_t ringbuffer_peek(ringbuffer_t *ring, uint8_t *dst, uint16_t size)
+uint16_t virtio_buffer_peek(virtio_buffer_t *ring, uint8_t *dst, uint16_t size)
 {
-  size = min(size, ringbuffer_read_available(ring));
+  size = min(size, virtio_buffer_read_available(ring));
   uint16_t recv_size = 0;
   while (recv_size < size) {
     recv_size += read_tmp(ring, dst + recv_size, size - recv_size);
@@ -97,7 +97,7 @@ uint16_t ringbuffer_peek(ringbuffer_t *ring, uint8_t *dst, uint16_t size)
   return recv_size;
 }
 
-uint16_t ringbuffer_write_available(ringbuffer_t *ring)
+uint16_t virtio_buffer_write_available(virtio_buffer_t *ring)
 {
   // This will make the function safe when read openrations are done in interrupts
   volatile uint16_t read = ring->read;
@@ -108,7 +108,7 @@ uint16_t ringbuffer_write_available(ringbuffer_t *ring)
   return read + (BUFFER_END - ring->write);
 }
 
-uint16_t ringbuffer_write(ringbuffer_t *ring, uint8_t *src, uint16_t size)
+uint16_t virtio_buffer_write(virtio_buffer_t *ring, uint8_t *src, uint16_t size)
 {
   // This will make the function safe when read openrations are done in a interrupt
   volatile uint16_t read = ring->read;

cores/arduino/stm32/virtio/ringbuffer.h renamed to cores/arduino/stm32/virtio/virtio_buffer.h

@@ -21,35 +21,35 @@
  * THE SOFTWARE.
  */
 
-#ifndef __VIRTIO_RINGBUFFER_H
-#define __VIRTIO_RINGBUFFER_H
+#ifndef __VIRTIO_BUFFER_H
+#define __VIRTIO_BUFFER_H
 
 #include <stdint.h>
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
-#define VIRTIO_RINGBUFFER_SIZE (RPMSG_BUFFER_SIZE * 2)
+#define VIRTIO_BUFFER_SIZE (RPMSG_BUFFER_SIZE * 2)
 
 typedef struct {
-  uint8_t buffer[VIRTIO_RINGBUFFER_SIZE];
+  uint8_t buffer[VIRTIO_BUFFER_SIZE];
   volatile uint16_t write;
   volatile uint16_t read;
   volatile uint16_t read_tmp;
-} ringbuffer_t;
+} virtio_buffer_t;
 
-void ringbuffer_init(ringbuffer_t *ring);
+void virtio_buffer_init(virtio_buffer_t *ring);
 
-uint16_t ringbuffer_read_available(ringbuffer_t *ring);
-uint16_t ringbuffer_read(ringbuffer_t *ring, uint8_t *dst, uint16_t size);
-uint16_t ringbuffer_peek(ringbuffer_t *ring, uint8_t *dst, uint16_t size);
+uint16_t virtio_buffer_read_available(virtio_buffer_t *ring);
+uint16_t virtio_buffer_read(virtio_buffer_t *ring, uint8_t *dst, uint16_t size);
+uint16_t virtio_buffer_peek(virtio_buffer_t *ring, uint8_t *dst, uint16_t size);
 
-uint16_t ringbuffer_write_available(ringbuffer_t *ring);
-uint16_t ringbuffer_write(ringbuffer_t *ring, uint8_t *src, uint16_t size);
+uint16_t virtio_buffer_write_available(virtio_buffer_t *ring);
+uint16_t virtio_buffer_write(virtio_buffer_t *ring, uint8_t *src, uint16_t size);
 
 #ifdef __cplusplus
 }
 #endif
 
-#endif // __VIRTIO_RINGBUFFER_H
+#endif // __VIRTIO_VIRTIO_BUFFER_H