Syntax highlighting

Author: wizard97

README.md

@@ -17,15 +17,15 @@ I decided to give object oriented programming a shot using only C (no C++) with
 
 Fine. I reluctantly wrapped the C stuff in a C++ class called `RingBufC`. All the methods are the same, except you no longer have to pass the this/self pointer. You can use either.
 
-```
+```c++
 // If you want to use C...
 char *mystr = "I like C";
 
 RingBuf *buf = RingBuf_new(sizeof(char*), 100);
 buf->add(buf, &mystr);
 ```
 
-```
+```c++
 // If you want to use the C++ wrapper
 char *mystr = "C++ has pretty object.method() syntax";
 
@@ -64,7 +64,7 @@ Feel free to improve this library. Fork it, make your changes, then submit a pul
 
 ### Constructor
 
-```
+```c++
 RingBuf *RingBuf_new(int size, int len);
 ```
 
@@ -73,7 +73,7 @@ This would be the equivalent of `new RingBuf(int size, int len)` in C++.
 
 ### Deconstructor
 
-```
+```c++
 int RingBuf_delete(RingBuf *self);
 ```
 
@@ -84,38 +84,38 @@ Deletes the RingBuf, and frees up all the memory associated with it.
 
 ### add()
 
-```
+```c++
 int add(RingBuf *self, void *object);
 ```
 
 Append an element to the buffer, where object is a pointer to object you wish to append. Returns -1 on a full buffer. On success, returns the position (index) in the buffer where the element was added.
 
 ### peek()
 
-```
+```c++
 void *peek(RingBuf *self, unsigned int num);
 ```
 
 Peek at the num'th element in the buffer. Returns a void pointer to the location of the num'th element. If num is out of bounds or the num'th element is empty, a NULL pointer is returned. Cast the result of this call into a pointer of whatever type you are storing in the buffer. Note that this gives you direct memory access to the location of the num'th element in the buffer, allowing you to directly edit elements in the buffer. Note that while all of RingBuf's public methods are thread safe (including this one), directly using the pointer returned from this method is not thread safe. If there is a possibility an interrupt could fire and remove/modify the item pointed to by the returned pointer, disable interrupts first with `noInterrupts()`, do whatever you need to do with the pointer, then you can reenable interrupts by calling `interrupts()`.
 
 ### pull()
 
-```
+```c++
 void *pull(RingBuf *self, void *object);
 ```
 
 Pull the first element out of the buffer. The first element is copied into the location pointed to by object. Returns a NULL pointer if the buffer is empty, otherwise returns object.
 
 
 ### numElements()
-```
+```c++
 unsigned int numElements(RingBuf *self);
 ```
 
 Returns number of elements in buffer.
 
 ### isFull()
-```
+```c++
 bool isFull(RingBuf *self);
 ```
 
@@ -124,7 +124,7 @@ Returns true if buffer is full, otherwise false.
 
 ### isEmpty()
 
-```
+```c++
 bool isEmpty(RingBuf *self);
 ```