Oops - re-order Ringbuffer.h inline functions to prevent compile errors due to forwar...

diff --git a/LUFA/Drivers/Misc/RingBuffer.h b/LUFA/Drivers/Misc/RingBuffer.h
index 937cb4a..3547c52 100644 (file)
--- a/LUFA/Drivers/Misc/RingBuffer.h
+++ b/LUFA/Drivers/Misc/RingBuffer.h
@@ -126,7 +126,7 @@
                 *  \param[out] DataPtr  Pointer to a global array that will hold the data stored into the ring buffer.\r
                 *  \param[out] Size     Maximum number of bytes that can be stored in the underlying data array.\r
                 */\r
                 *  \param[out] DataPtr  Pointer to a global array that will hold the data stored into the ring buffer.\r
                 *  \param[out] Size     Maximum number of bytes that can be stored in the underlying data array.\r
                 */\r

-               static inline void RingBuffer_InitBuffer(RingBuffer_t* const Buffer, uint8_t* const DataPtr, const uint16_t Size)\r
+               static inline void RingBuffer_InitBuffer(RingBuffer_t* Buffer, uint8_t* const DataPtr, const uint16_t Size)\r

                {\r
                        GCC_FORCE_POINTER_ACCESS(Buffer);\r
 \r
                {\r
                        GCC_FORCE_POINTER_ACCESS(Buffer);\r
 \r


@@ -143,23 +143,6 @@
                        SetGlobalInterruptMask(CurrentGlobalInt);\r
                }\r
 \r
                        SetGlobalInterruptMask(CurrentGlobalInt);\r
                }\r
 \r

-               /** Retrieves the free space in a particular buffer. This value is computed by entering an atomic lock\r
-                *  on the buffer, so that the buffer cannot be modified while the computation takes place.\r
-                *\r
-                *  \note The value returned by this function is guaranteed to only be the maximum number of bytes\r
-                *        free in the given buffer; this value may change as other threads write new data, thus\r
-                *        the returned number should be used only to determine how many successive writes may safely\r
-                *        be performed on the buffer when there is a single writer thread.\r
-                *\r
-                *  \param[in] Buffer  Pointer to a ring buffer structure whose free count is to be computed.\r
-                *\r
-                *  \return Number of free bytes in the buffer.\r
-                */\r
-               static inline uint16_t RingBuffer_GetFreeCount(RingBuffer_t* const Buffer)\r
-               {\r
-                       return (Buffer->Size - RingBuffer_GetCount(Buffer));\r
-               }\r
-\r

                /** Retrieves the current number of bytes stored in a particular buffer. This value is computed\r
                 *  by entering an atomic lock on the buffer, so that the buffer cannot be modified while the\r
                 *  computation takes place. This value should be cached when reading out the contents of the buffer,\r
                /** Retrieves the current number of bytes stored in a particular buffer. This value is computed\r
                 *  by entering an atomic lock on the buffer, so that the buffer cannot be modified while the\r
                 *  computation takes place. This value should be cached when reading out the contents of the buffer,\r


@@ -187,17 +170,21 @@
                        return Count;\r
                }\r
 \r
                        return Count;\r
                }\r
 \r

-               /** Atomically determines if the specified ring buffer contains any free space. This should\r
-                *  be tested before storing data to the buffer, to ensure that no data is lost due to a\r
-                *  buffer overrun.\r
+               /** Retrieves the free space in a particular buffer. This value is computed by entering an atomic lock\r
+                *  on the buffer, so that the buffer cannot be modified while the computation takes place.\r

                 *\r
                 *\r

-                *  \param[in,out] Buffer  Pointer to a ring buffer structure to insert into.\r
+                *  \note The value returned by this function is guaranteed to only be the maximum number of bytes\r
+                *        free in the given buffer; this value may change as other threads write new data, thus\r
+                *        the returned number should be used only to determine how many successive writes may safely\r
+                *        be performed on the buffer when there is a single writer thread.\r

                 *\r
                 *\r

-                *  \return Boolean \c true if the buffer contains no free space, false otherwise.\r
+                *  \param[in] Buffer  Pointer to a ring buffer structure whose free count is to be computed.\r
+                *\r
+                *  \return Number of free bytes in the buffer.\r

                 */\r
                 */\r

-               static inline bool RingBuffer_IsFull(RingBuffer_t* const Buffer)\r
+               static inline uint16_t RingBuffer_GetFreeCount(RingBuffer_t* const Buffer)\r

                {\r
                {\r

-                       return (RingBuffer_GetCount(Buffer) == Buffer->Size);\r
+                       return (Buffer->Size - RingBuffer_GetCount(Buffer));\r

                }\r
 \r
                /** Atomically determines if the specified ring buffer contains any data. This should\r
                }\r
 \r
                /** Atomically determines if the specified ring buffer contains any data. This should\r


@@ -217,6 +204,19 @@
                        return (RingBuffer_GetCount(Buffer) == 0);\r
                }\r
 \r
                        return (RingBuffer_GetCount(Buffer) == 0);\r
                }\r
 \r

+               /** Atomically determines if the specified ring buffer contains any free space. This should\r
+                *  be tested before storing data to the buffer, to ensure that no data is lost due to a\r
+                *  buffer overrun.\r
+                *\r
+                *  \param[in,out] Buffer  Pointer to a ring buffer structure to insert into.\r
+                *\r
+                *  \return Boolean \c true if the buffer contains no free space, false otherwise.\r
+                */\r
+               static inline bool RingBuffer_IsFull(RingBuffer_t* const Buffer)\r
+               {\r
+                       return (RingBuffer_GetCount(Buffer) == Buffer->Size);\r
+               }\r
+\r

                /** Inserts an element into the ring buffer.\r
                 *\r
                 *  \note Only one execution thread (main program thread or an ISR) may insert into a single buffer\r
                /** Inserts an element into the ring buffer.\r
                 *\r
                 *  \note Only one execution thread (main program thread or an ISR) may insert into a single buffer\r