C: circular buffer

c/circular-buffer/GNUmakefile

@@ -0,0 +1,51 @@
+# The original 'makefile' has a flaw:
+# 1) it overrides CFLAGS
+# 2) it does not pass extra "FLAGS" to $(CC) that could come from environment
+#
+# It means :
+# - we need to edit 'makefile' for different builds (DEBUG, etc...), which is
+#   not practical at all.
+# - Also, it does not allow to run all tests without editing the test source
+#   code.
+#
+# To use this makefile (GNU make only):
+#   "make": build with all predefined tests (without editing test source code)
+#   "make debugall": build with all predefined tests and debug code
+#   "make mem": perform memcheck with all tests enabled
+#   "make unit": build standalone (unit) test
+#   "make debug": build standalone test with debugging code
+#
+# Original 'makefile' targets can be used (test, memcheck, clean, ...)
+
+.PHONY: default all mem unit debug std debugtest
+
+default: all
+
+# default is to build with all predefined tests
+BUILD := teststall
+
+include makefile
+
+all: CFLAGS+=-DTESTALL
+all: clean test
+
+debugall: CFLAGS+=-DDEBUG
+debugall: all
+
+debugtest: CFLAGS+=-DDEBUG
+debugtest: test
+
+mem: CFLAGS+=-DTESTALL
+mem: clean memcheck
+
+unit: CFLAGS+=-DUNIT_TEST
+unit: clean std
+
+debug: CFLAGS+=-DUNIT_TEST -DDEBUG
+debug: clean std
+
+debugtest: CFLAGS+=-DDEBUG
+debugtest: test
+
+std: src/*.c src/*.h
+	$(CC) $(CFLAGS) src/*.c -o tests.out  $(LIBS)

c/circular-buffer/README.md

@@ -0,0 +1,89 @@
+# Circular Buffer
+
+A circular buffer, cyclic buffer or ring buffer is a data structure that
+uses a single, fixed-size buffer as if it were connected end-to-end.
+
+A circular buffer first starts empty and of some predefined length. For
+example, this is a 7-element buffer:
+
+    [ ][ ][ ][ ][ ][ ][ ]
+
+Assume that a 1 is written into the middle of the buffer (exact starting
+location does not matter in a circular buffer):
+
+    [ ][ ][ ][1][ ][ ][ ]
+
+Then assume that two more elements are added — 2 & 3 — which get
+appended after the 1:
+
+    [ ][ ][ ][1][2][3][ ]
+
+If two elements are then removed from the buffer, the oldest values
+inside the buffer are removed. The two elements removed, in this case,
+are 1 & 2, leaving the buffer with just a 3:
+
+    [ ][ ][ ][ ][ ][3][ ]
+
+If the buffer has 7 elements then it is completely full:
+
+    [6][7][8][9][3][4][5]
+
+When the buffer is full an error will be raised, alerting the client
+that further writes are blocked until a slot becomes free.
+
+When the buffer is full, the client can opt to overwrite the oldest
+data with a forced write. In this case, two more elements — A & B —
+are added and they overwrite the 3 & 4:
+
+    [6][7][8][9][A][B][5]
+
+3 & 4 have been replaced by A & B making 5 now the oldest data in the
+buffer. Finally, if two elements are removed then what would be
+returned is 5 & 6 yielding the buffer:
+
+    [ ][7][8][9][A][B][ ]
+
+Because there is space available, if the client again uses overwrite
+to store C & D then the space where 5 & 6 were stored previously will
+be used not the location of 7 & 8. 7 is still the oldest element and
+the buffer is once again full.
+
+    [D][7][8][9][A][B][C]
+
+## Getting Started
+
+Make sure you have read the "Guides" section of the
+[C track][c-track] on the Exercism site. This covers
+the basic information on setting up the development environment expected
+by the exercises.
+
+## Passing the Tests
+
+Get the first test compiling, linking and passing by following the [three
+rules of test-driven development][3-tdd-rules].
+
+The included makefile can be used to create and run the tests using the `test`
+task.
+
+    make test
+
+Create just the functions you need to satisfy any compiler errors and get the
+test to fail. Then write just enough code to get the test to pass. Once you've
+done that, move onto the next test.
+
+As you progress through the tests, take the time to refactor your
+implementation for readability and expressiveness and then go on to the next
+test.
+
+Try to use standard C99 facilities in preference to writing your own
+low-level algorithms or facilities by hand.
+
+## Source
+
+Wikipedia [http://en.wikipedia.org/wiki/Circular_buffer](http://en.wikipedia.org/wiki/Circular_buffer)
+
+## Submitting Incomplete Solutions
+It's possible to submit an incomplete solution so you can see how others have completed the exercise.
+
+[c-track]: https://exercism.io/my/tracks/c
+[3-tdd-rules]: http://butunclebob.com/ArticleS.UncleBob.TheThreeRulesOfTdd

c/circular-buffer/makefile

@@ -0,0 +1,37 @@
+### If you wish to use extra libraries (math.h for instance),
+### add their flags here (-lm in our case) in the "LIBS" variable.
+
+LIBS = -lm
+
+###
+CFLAGS  = -std=c99
+CFLAGS += -g
+CFLAGS += -Wall
+CFLAGS += -Wextra
+CFLAGS += -pedantic
+CFLAGS += -Werror
+CFLAGS += -Wmissing-declarations
+CFLAGS += -DUNITY_SUPPORT_64
+
+ASANFLAGS  = -fsanitize=address
+ASANFLAGS += -fno-common
+ASANFLAGS += -fno-omit-frame-pointer
+
+.PHONY: test
+test: tests.out
+	@./tests.out
+
+.PHONY: memcheck
+memcheck: test/*.c src/*.c src/*.h
+	@echo Compiling $@
+	@$(CC) $(ASANFLAGS) $(CFLAGS) src/*.c test/vendor/unity.c test/*.c -o memcheck.out $(LIBS)
+	@./memcheck.out
+	@echo "Memory check passed"
+
+.PHONY: clean
+clean:
+	rm -rf *.o *.out *.out.dSYM
+
+tests.out: test/*.c src/*.c src/*.h
+	@echo Compiling $@
+	@$(CC) $(CFLAGS) src/*.c test/vendor/unity.c test/*.c -o tests.out $(LIBS)

c/circular-buffer/src/circular_buffer.c

@@ -0,0 +1,75 @@
+#include <malloc.h>
+#include <errno.h>
+
+#include "circular_buffer.h"
+
+#define INC(v, size) {if (++v==size) v=0;}
+
+circular_buffer_t *new_circular_buffer(size_t size)
+{
+    circular_buffer_t *head = NULL;
+
+    if (size > 0) {
+        if ((head=malloc(sizeof(*head)))) {
+            clear_buffer(head);
+            head->size = size;
+            /* we could have only 1 alloc, I just prefer this double alloc
+             */
+            if (!(head->buf  = calloc(size, sizeof(buffer_value_t)))) {
+                free(head);
+                head = NULL;
+            }
+        }
+    }
+    return head;
+}
+
+int do_write(circular_buffer_t *b, buffer_value_t v, int f)
+{
+    if (!f  && b->used == b->size) {
+        errno = ENOBUFS;
+        return EXIT_FAILURE;
+    }
+    b->buf[b->head] = v;
+    INC(b->head, b->size);
+    if (f && b->used == b->size)                  /* overwrite and full */
+        INC(b->tail, b->size);
+    if (b->used < b->size)                        /* normal write */
+        b->used++;
+    return EXIT_SUCCESS;
+}
+
+int read(circular_buffer_t *b, buffer_value_t *p)
+{
+    if (!b->used) {
+        errno = ENODATA;
+        return EXIT_FAILURE;
+    }
+    b->used--;
+    *p = b->buf[b->tail];
+    INC(b->tail, b->size);
+    return EXIT_SUCCESS;
+}
+
+int clear_buffer(circular_buffer_t *b)
+{
+    b->head = 0;
+    b->tail = 0;
+    b->used = 0;
+    return EXIT_SUCCESS;
+}
+
+void delete_buffer(circular_buffer_t *b) {
+    free(b->buf);
+    free(b);
+}
+
+/* See GNUmakefile below for explanation
+ * https://github.com/braoult/exercism/blob/master/c/templates/GNUmakefile
+ */
+#ifdef UNIT_TEST
+int main(int ac, char **av)
+{
+    /* not done for circular buffer : simple exercise, with difficult testing */
+}
+#endif

c/circular-buffer/src/circular_buffer.h

@@ -0,0 +1,41 @@
+#ifndef CIRCULAR_BUFFER_H
+#define CIRCULAR_BUFFER_H
+
+#include <stdlib.h>
+
+typedef char buffer_value_t;
+
+/* used and tail are redundant, but allow easier code (and maybe easier
+ * to read ?).
+ */
+typedef struct circular_buffer {
+    int head;
+    int tail;
+    int used;
+    int size;
+    buffer_value_t *buf;
+} circular_buffer_t;
+
+extern circular_buffer_t *new_circular_buffer(size_t size);
+extern int do_write(circular_buffer_t *buffer, buffer_value_t value, int force);
+extern int read(circular_buffer_t *buffer, buffer_value_t *retval);
+extern int clear_buffer(circular_buffer_t *buffer);
+extern void delete_buffer(circular_buffer_t *buffer);
+
+#define write(buffer, value)     do_write((buffer), (value), 0)
+#define overwrite(buffer, value) do_write((buffer), (value), 1)
+
+/* See GNUmakefile below for explanation
+ * https://github.com/braoult/exercism/blob/master/c/templates/GNUmakefile
+ */
+#if defined UNIT_TEST || defined DEBUG
+#include <stdio.h>
+#include <stdlib.h>
+#endif
+
+#ifdef  TESTALL
+#undef  TEST_IGNORE
+#define TEST_IGNORE() {}
+#endif
+
+#endif