Initial commit.

This adds the following components:
* Public interface for the logging system, and for adding logging
callbacks to libcallbacks.
* Core implementation of the logging system and a function for adding
libcallbacks logging calls.
* The libcallbacks functions for logging all callbacks.
Add .gitignore to ignore object files.

This will be more useful when a Makefile is added that produces *.o
files automatically.
Correct header guard name.

addlog.h was formerly named create.h; this change was not properly
reflected in the header guard name.
Add extern type qualifier to header functions.

This is consistent with every other header function prototype.
Change header guard naming convention.

Previously the syntax was:

	_[DIR_]FILE_H

This standard violates the C standard for reserved identifiers; all
variables starting with a _ followed by a capital letter are reserved
for system header implementations.

As such, the syntax has now changed to:

	NAME_[DIR_]FILE_H

Where NAME is the name of the program it is a component of. This ensures
that the header guard name is unique and does not violate the C
standard.
Fix a bug with add.c's use of libcallbacks.

The add_logger() function was creating all of the sp2_*_callbacks with
pointers to the appropriate logging functions, and setting the nested
pointers to the lower structs. Then it added each struct type using its
corresponding function.

This is redundant because adding a sp2_session_callbacks struct with
a nested pointer to the corresponding sp2_playlistcontainer_callbacks
and in turn the nested sp2_playlist_callbacks will add all of the
callbacks. However, in addition to this we were using the
sp2_playlistcontainer_add_callbacks() and sp2_playlist_add_callbacks()
functions to add the same callbacks again.
Do not extern function declarations.

Use of the extern keyword with functions is unnecessary because they do
not have a default initialization. This contrasts with variables where
extern is necessary to explicitly state that a variable is defined
elsewhere, instead of using a default initialization.
Include double verification headers.

This changes source files to include their own headers for type checking
of the symbols they provide.
The file in question, log.c, only needed stdlib.h for NULL. Since
stddef.h is a strict subset of stdlib.h, it makes more sense to only
include stddef.h.
Reorganize #include directive order.

Previously the (general) style standard used was as follows:

	system headers
	local headers in another directory
	local headers in the current directory

Each of the three groups was then further ordered loosely based on the
generality of the header in question, such that the first headers listed
were the most general and the last the most specific.

The change enacted by this commit reverses the three groups.
Additionally, a source file should include its corresponding header file
first, if it exists.

This change was made to catch headers which were missing dependencies;
processing these headers before including the standard system libraries
will catch many if not all of the header dependency issues.
Change the sputil naming prefix from sp2_ to spu_.

This more clearly represents data belonging to sputil and emphasizes
that it is not apart of any version of libspotify.
Change the global variable naming convention.

Previously we were prefixing global variables with g_. This commit
changes the prefix to spu_, which is consistent with the (new) function
naming convention.
Use the new libcallbacks interface.

This replaces the callback type specific callback functions (e.g.
spu_session_add_callbacks()) with the new generalized function calls,
with the type as an argument.
Add a new function for setting the sp_session.

This commit adds a function for setting the global sp_session that is
required by various log() calls. It should be set before making any
log() calls.

Previously this was being set by another object file by externing the
existence of the variable. Specifically, libcallbacks was setting it by
hard coding it into libspotify's logged_in() callback. This
functionality was removed, however, because it was inconsistent and a
very bad solution.
Change the configuration paradigm.

There are three points of configuration for liblog:
- Set the sp_session so that FATAL log levels work, and so that other
  advanced log_*() calls can get the information they need.
- Set a log level threshold for printing.
- Optionally set a log file instead of stdout and stderr.

Previously we were setting these by simply externing global variables
that needed to be defined by some other object file (typically the
application using liblog). This worked, but isn't that elegant; it
pollutes the global namespace.

Commit 9d60460faa25fe3b4c82e342f96080d2ea8e99ab introduced a change that
would set the sp_session variable as a static variable in core/log.c by
passing it in via a function. This allows a more clean form of
configuration.

Extending on this idea, this commit adds a new struct, spu_log_config,
which is responsible for setting all three points of configuration. This
is now passed into spu_configure_log(), sets the struct as a static
global variable inside core/log.c.

This is the same method that libspotify uses for configuration (when you
pass in sp_session_config to sp_session_create()).
exit() after a FATAL log.

Previously we were just logging out with sp_session_logout(), which will
not terminate the program (it will just do nothing as the main thread
continually runs sp_session_process_events()).
Change filenames for consistency.

This moves callbacks/container.{c,h} to
callbacks/playlistcontainer.{c,h}. This is consistent with all other
naming conventions used within sputil and libspotify.
Add shared library files to the .gitignore.
Make all callback functions static.

Previously we were giving every callback external linkage, and
constructing the corresponding structs in a separate translation unit.
This polluted the global namespace unnecessairily and required overly
specific function names to use to avoid symbol collisions.

This commit makes every function static, and defines the corresponding
callback struct as a global variable with external linkage, in the same
translation unit as the function definitions.
Update header guard naming convention.

This commit is the first in a series of commits that will update naming
conventions to the following standard:

All global symbols must be prefixed with spu*_, where * is the shortest
possible identification of the library. For instance, libcallbacks is
"c," while liblog would be "l."