It seems like MingW64's size_t is defined differently than in Linux.

This change fixes a bunch of warnings that were discovered by compiling
with `clang -target=i386-pc-linux-gnu`. It turned out that the
intrinsics were not necessarily being used in all platforms! Especially
in GCC, since it does not support __has_builtin.

Some more warnings were gleaned from the Windows build, but I stopped
when I saw that some third-party dependencies (e.g. zlib) have warnings
of their own, so we might never be able to enable -Werror there.

Shutdown callback count

Update CRLF filtering to match modern git

We currently have an explicit callchain of all the initialization
callbacks in our `init_common` function. This is perfectly fine, but
requires us to manually keep track of how many shutdown callbacks there
may be installed: to avoid allocations before libgit2 is fully
initialized, we assume that every initializer may register at most one
shutdown function. These shutdown functions are stored in a static array
of size `MAX_SHUTDOWN_CB`, which then needs to be updated manually
whenever a new initializer function is being added.

The situation can be easily fixed: convert the callchain of init
functions into an array and iterate over it to initialize all
subsystems. This allows us to define the `git__shutdown_callbacks` array
with the same size as the initializer array and rids us of the need to
always update `MAX_SHUTDOWN_CB`.

The `git_hash_global_init` function is simply defined as a macro to zero
for most of the different hash implementations. This makes it impossible
to treat it like a function pointer, which is required for a later
commit where we want to improve the way global initialization works.
Fix the issue by converting all no-op macros to an inline function
returning zero.

There's a small gotcha here, though: as most hash implementations only
have a header file, but not a corresponding implementation file, we
cannot declare the function as non-static. But declaring it as `static
inline` fails, too, as there is a previous declaration as non-static. So
we have to move the function declaration after the include that brings
in the function definition, as it is allowed to have a non-static
declaration after a static definition, but not the other way round.

Wrap function calls in the `checkout::crlf` tests with `cl_git_pass`,
`cl_assert`, etc. to ensure that they're successful.

refdb_fs: refactor error handling in `refdb_reflog_fs__delete`

The function `refdb_reflog_fs__delete` uses the `if (!error && foobar())`
pattern of checking, where error conditions are being checked by following calls
to different code. This does not match our current style, where the call-site of
a function is usually directly responsible for checking the return value.

Convert the function to use `if ((error = foobar()) < 0) goto out;` style. Note
that this changes the code flow a bit: previously, we were always trying to
delete empty reference hierarchies even if deleting the reflog entry has failed.
This wasn't much of a problem -- if deletion failed, the hierarchy will still
contain at least one file and thus the function call was an expensive no-op.
Now, we will only perform this deletion if we have successfully removed the
reflog.

Remove empty (sub-)directories when deleting refs

Support creating annotated commits from annotated tags

We want to allow the creation of annotated commits out of annotated tags and for
that we have to peel the reference all the way to the commit instead of stopping
at the first id it provides.

We have no need to take a non-const reference. This does involve some other work
to make sure we don't mix const and non-const variables, but by splitting what
we want each variable to do we can also simplify the logic for when we do want
to free a new reference we might have allocated.

Fix segfault in loose_backend__readstream

make proxy_stream_close close target stream even on errors

When git_filter_apply_fn callback returns a error while smudging proxy_stream_close
ends up returning without closing the stream. This is turn makes blob_content_to_file
crash as it asserts the stream being closed whether there are errors or not.

Closing the target stream on error fixes this problem.

If the routine exits with error before stream or hash_ctx is initialized, the
program will segfault when trying to free them.

This is a cherry-pick of the tests from the following commits:

core.autocrlf=true and core.safecrlf=true did not fail on LF-only file as vanilla git does
Adding a CRLF-file with core.autocrlf=input and core.safecrlf=true does not fail as with vanilla git
Make files with #CR!=#CRLF not fail with core.safecrlf=true

Reported-by: Yue Lin Ho <b8732003@student.nsysu.edu.tw>
Signed-off-by: Sven Strickroth <email@cs-ware.de>

Examine the recent CRLF changes to git by Torsten Bögershausen and
include similar changes to update our CRLF logic to match.

Note: Torsten Bögershausen has previously agreed to allow his changes to
be included in libgit2.

Don't simply fail when the expected output does not match the data in
the index; instead, provide a detailed output about the system, file,
and settings that caused the failure so that developers can better
isolate the problem(s).

Given a variety of combinations of core.autocrlf, core.safecrlf settings
and attributes settings, test that we add files to index the same way
(regarding OIDs and fatal errors) as a known-good test resource created
by git.git.

Signed-off-by: Sven Strickroth <email@cs-ware.de>

Use the crlf data scripts to produce a corpus of known-good data in
"git" format (aka ODB format) from a variety of files with different
line endings.  `git` created these files running `git add` to stage the
contents then extracting the data from the repository.

We'll use these to ensure that we create identical contents when we add
files into the index.

Re-use the existing crlf data generation script for creating the to-odb
dataset.  Also, store the actual file contents instead of the ID so that
we can identify differences instead of detecting that differences exist.

Include a shell script that will generate the expected data of OIDs and
failures for calling git.git to capture its output as a test resource.

Right now, there is no need to differentiate different systems as git behaves
the same on all systems IIRC.

Signed-off-by: Sven Strickroth <email@cs-ware.de>

After sandboxing the crlf directory, remove the working directory
contents.  This allows us to package data within the crlf directory
(for simplicity, this allows us to script the to-odb and to-workdir
crlf filter conversion data in a single location).

Move the crlf_data folders reponsible for holding the state of the
filters going into the working directory to "to_workdir" variations of
the folder name to accommodate future growth into the "to odb" filter
variation.  Update the script to create these new folders as appopriate.

Index API updates for consistency

Use the new object_type enumeration names within the codebase.

Use the new-style index names throughout our own codebase.

git_object_t is the future; update the public API to use it.  This will
also ensure that we can build our tests which make use of the old API
without modification (and without compiler warnings).

The two "reserved" bits in `git_object_t` are unused.  They were
included for completeness, but downstream users should never use them
and they should not have been made public.

These values are never set.

With the refactoring of `git_otype` into `git_object_t`, we can remove
these from the new API.  They will remain in the old (deprecated) API
in the unlikely event that someone was using them.

Update the `git_otype` names to reflect our current naming conventions.
`git_otype` is now `git_object_t` and the `GIT_OBJ_*` values are now
`GIT_OBJECT_*` values.

The old macro, enumeration and structure names are retained and simply
set to the new names.

We have various macro, enumeration and structure names that were
introduced (very) early in the project and do not match our current
naming conventions.  For instance: `GIT_IDXENTRY...` flags that
correspond to a structure named `git_index_entry`.

Update these to match the current guidance.  The old macros and
enumeration names are reflected as new macros in order to support
backward compatibility (and do so without warnings for consumers).

Allow merge analysis against any reference

revwalk: Allow changing hide_cb