It begins.
Don't use NULL terminated strings.

The use of NULL terminated strings prevents data streams from using
zero. This commit adds a simple struct and changes the typedefs to pass
a size_t size explicitly.
Add a note about thread safety for out().
Restructure the leo() prototype again.

This commit passes data by reference to both in() and out(). This change
was made because it's consistent between callbacks, and because many
libraries use this convention.

Additionally, in() now returns an int value to decide whether processing
should continue.
Clarify FILE *memory documentation.

This commit notes that FILE *memory should be opened in read write
binary mode.
Implement memory preprocessing in leo().

This commit adds a static function, process_memory(), which processes
new and preexisting memory files correctly. Specifically, it adds a
magic number and returns any errors.

Because there may be an error in process_error(), leo() has been changed
to return an int so that this information can be properly reported to
the caller.
Get rid of struct data and change the prototypes.

This commit removes the data struct that was defined in leornian.h and
used in the in() and out() function pointer prototypes passed to leo().

This change was made so that files wishing to implement in() and out()
for a later leo() call need no include leornian.h. Specifically, a
planned future daemon using a plugin structure to modularly define in()
and out() functions will benefit from this.
Restructure prototype comments.

Instead of having one enormous blob comment for the entire prototype,
this moves the comments for each parameter to their own comment blocks
immediately before the corresponding parameter declaration.
Use in() and out() in leo().

This commit creates a simple loop to operate on every bit of data from
in() and constructs a string of bits to provide to out(). This
implementation is mostly for debugging and further development.
Add paranoid macro parenthesis.

This commit adds parenthesis around the arguments to GET_BIT(), in case
these arguments have operators that would get overridden by the
precedence of operators present in the macro.
Access bits in the reverse order.

This commit makes GET_BIT() access every bit of a byte from left to
right instead of right to left.

This distinction is important because any algorithm will not operate on
a group of distinct bytes, but rather a stream of bits. The order of
these bits must be preserved.
Add a cmake configuration file.

This commit adds CMakeLists.txt, a cmake configuration file for building
libleornian as a shared library on any cmake supported platform.
Add compiler warning flags to CMakeLists.txt.

This commit adds a conditional check for the compiler and adds
appropriate warning flags for it.
Revert "Access bits in the reverse order."

This reverts commit efe175b0221091722fba0590f9f1c6f159c3a82a.

The correct order to access each bit is arbitrary; the commit in
question was conforming to big endian systems. This distinction is
meaningless, and only added more complexity to a performance critical
algorithm.

Reverting this commit accesses each bit little endian, i.e. the least
significant bit is read first.
Comment the GET_BIT() macro.
Move process_memory() to the public interface.

This commit moves process_memory(), its function comments, and its
associated #define directives, to the public leornian.h header file.
This commit also renames process_memory() to leo_mem().

Additional comments are added clarifying the relationship between leo()
and leo_mem().
Add convenience macros for working with bits.

This commit removes GET_BIT() and its comment, and adds several modular
bit manipulation macros, each with their own comments.
Change macro function style convention.

This commit removes the space between each macro function line and the
trailing \. This decision was made because it's easier to write, and in
my opinion easier to read.
Add a WIDTH parameter to BIT_MASK().

This commit adds WIDTH, which specifies the amount of bits to be set in
the resulting mask.
Generalize bit arrays in the bit macros.

This commit adds BIT_ARRY(), a macro for wrapping one of the bit
operations (SET, CLEAR, TEST) on a bit in a bit array.

Previously, each operation (SET, ...) hard coded the use of a bit array.
This is redundant and causes issues when using literal values instead of
arrays.