Merge pull request #42 from camgunz/develop

Merge from develop

Author: camgunz

.gitignore

@@ -26,6 +26,21 @@
 *.swp
 *.swo
 
+# Coverage files
+*.gcda
+*.gcno
+
 # Testing executable
 test/test-cmp
+cmptest
+cmptest2
+
+# Example executables
+examples/example1
+examples/example2
+example1
+example2
+
+# Test data
+cmp_data.dat
 

.travis.yml

@@ -1,7 +1,22 @@
-language: cpp
-compiler: clang
+dist: trusty
+sudo: false
+language: c
+compiler: gcc
+
+addons:
+  apt:
+    packages:
+      - build-essential
+      - python-dev
+      - libffi-dev
+      - libssl-dev
+      - libcmocka-dev
+
+before_install:
+  - pip install --user cpp-coveralls
 
 script:
-  - examples/build_examples.sh
-  - examples/example1
-  - examples/example2
+  - make test
+
+after_success:
+  - coveralls --gcov-options '\-lp' -i cmp.c -i cmp.h -e test/utils.c -e test/buf.c -e test/test.c -e test/buf.h -e test/utils.h -e examples/example1.c -e examples/example2.c

Makefile

@@ -0,0 +1,40 @@
+CC ?= gcc
+
+CFLAGS ?= -Werror -Wall -Wextra -funsigned-char -fwrapv -Wconversion -Wno-sign-conversion -Wmissing-format-attribute -Wpointer-arith -Wformat-nonliteral -Winit-self -Wwrite-strings -Wshadow -Wenum-compare -Wempty-body -Wparentheses -Wcast-align -Wstrict-aliasing --pedantic-errors
+
+.PHONY: all clean test coverage
+
+all: cmptest example1 example2
+
+test: cmptest
+	@./cmptest
+
+cmp.o:
+	$(CC) $(CFLAGS) --std=c89 -fprofile-arcs -ftest-coverage -g -O0 -I. -c cmp.c
+
+cmptest: cmp.o
+	$(CC) $(CFLAGS) -Wno-error=deprecated-declarations -Wno-deprecated-declarations --std=c99 -I. -fprofile-arcs -ftest-coverage -g -O0 -o cmptest cmp.o test/test.c test/buf.c test/utils.c -lcmocka
+
+example1:
+	$(CC) $(CFLAGS) --std=c89 -O3 -I. -o example1 cmp.c examples/example1.c
+
+example2:
+	$(CC) $(CFLAGS) --std=c89 -O3 -I. -o example2 cmp.c examples/example2.c
+
+coverage:
+	@rm -f base_coverage.info test_coverage.info total_coverage.info
+	@rm -rf coverage
+	@lcov -q -c -i -d . -o base_coverage.info
+	@lcov -q -c -d . -o test_coverage.info
+	@lcov -q -a base_coverage.info -a test_coverage.info -o total_coverage.info
+	@lcov -q --summary total_coverage.info
+	@mkdir coverage
+	@genhtml -q -o coverage total_coverage.info
+
+clean:
+	@rm -f cmptest
+	@rm -f example1
+	@rm -f example2
+	@rm -f *.o
+	@rm -f *.gcno *.gcda *.info
+	@rm -f cmp_data.dat

README.md

@@ -1,4 +1,6 @@
-# cmp
+# CMP
+
+[![Build Status](https://travis-ci.org/camgunz/cmp.svg?branch=master)](https://travis-ci.org/camgunz/cmp) [![Coverage Status](https://coveralls.io/repos/github/camgunz/cmp/badge.svg?branch=develop)](https://coveralls.io/github/camgunz/cmp?branch=develop)
 
 CMP is a C implementation of the MessagePack serialization format.  It
 currently implements version 5 of the [MessagePack
@@ -32,6 +34,10 @@ static bool file_reader(cmp_ctx_t *ctx, void *data, size_t limit) {
     return read_bytes(data, limit, (FILE *)ctx->buf);
 }
 
+static bool file_skipper(cmp_ctx_t *ctx, size_t count) {
+    return fseek((FILE *)ctx->buf, count, SEEK_CUR);
+}
+
 static size_t file_writer(cmp_ctx_t *ctx, const void *data, size_t count) {
     return fwrite(data, sizeof(uint8_t), count, (FILE *)ctx->buf);
 }
@@ -54,7 +60,7 @@ int main(void) {
     if (fh == NULL)
         error_and_exit("Error opening data.dat");
 
-    cmp_init(&cmp, fh, file_reader, file_writer);
+    cmp_init(&cmp, fh, file_reader, file_skipper, file_writer);
 
     if (!cmp_write_array(&cmp, 2))
         error_and_exit(cmp_strerror(&cmp));
@@ -90,13 +96,14 @@ int main(void) {
     if (!cmp_read_str(&cmp, message_pack, &str_size))
         error_and_exit(cmp_strerror(&cmp));
 
-    printf("Array Length: %zu.\n", array_size);
+    printf("Array Length: %u.\n", array_size);
     printf("[\"%s\", \"%s\"]\n", hello, message_pack);
 
     fclose(fh);
 
     return EXIT_SUCCESS;
 }
+
 ```
 
 ## Advanced Usage
@@ -108,36 +115,35 @@ See the `examples` folder.
 CMP uses no internal buffers; conversions, encoding and decoding are done on
 the fly.
 
-CMP's source and header file together are ~3,300 LOC.
+CMP's source and header file together are ~4k LOC.
 
 CMP makes no heap allocations.
 
 CMP uses standardized types rather than declaring its own, and it depends only
-on `stdbool.h`, `stdint.h` and `string.h`.  It has no link-time dependencies,
-not even the C Standard Library.
+on `stdbool.h`, `stdint.h` and `string.h`.
 
 CMP is written using C89 (ANSI C), aside, of course, from its use of
 fixed-width integer types and `bool`.
 
-On the other hand, CMP's test suite depends upon the C Standard Library and
-requires C99.
+On the other hand, CMP's test suite requires C99.
 
-CMP only requires the programmer supply a read function and a write function.
-In this way, the programmer can use CMP on memory, files, sockets, etc.
+CMP only requires the programmer supply a read function, a write function, and
+an optional skip function.  In this way, the programmer can use CMP on memory,
+files, sockets, etc.
 
 CMP is portable.  It uses fixed-width integer types, and checks the endianness
 of the machine at runtime before swapping bytes (MessagePack is big-endian).
 
 CMP provides a fairly comprehensive error reporting mechanism modeled after
 `errno` and `strerror`.
 
-CMP is threadsafe; while contexts cannot be shared between threads, each thread
-may use its own context freely.
+CMP is thread aware; while contexts cannot be shared between threads, each
+thread may use its own context freely.
 
 CMP is tested using the MessagePack test suite as well as a large set of custom
 test cases.  Its small test program is compiled with clang using `-Wall -Werror
 -Wextra ...` along with several other flags, and generates no compilation
-errors.
+errors in either Clang or GCC.
 
 CMP's source is written as readably as possible, using explicit, descriptive
 variable names and a consistent, clear style.

TODO.md

@@ -1 +1,22 @@
+# To Do
+
+- Work on some kind of skipping
+  - Add a `skip` callback to `cmp_ctx_t`, because skipping is not always
+    reading
+  - Add `bool cmp_skip_object(cmp_ctx_t *ctx, cmp_object_t *obj, uint32_t limit)`
+  - Add `bool cmp_skip_object_no_limit(cmp_ctx_t *ctx, cmp_object_t *obj)`
+
+- Work on fixing double-copy issue
+  - Essentially everything is written to a `cmp_object_t` before it's written
+    out to the caller, which is inefficient.  The reasoning for this is to not
+    pollute the caller's environment should an error occur, but in practice
+    it's probably better to say, "you can't trust the contents of output
+    arguments you pass to CMP if the call fails".
+
+- Build real docs
+  - Probably still just a Markdown file, but still, things have gotten complex
+    enough that `cmp.h` and `README.md` don't really cover it anymore.
+
+- Consider using a real test framework
+
 - Prevent users from using extended types < 0 (reserved by MessagePack)