Still trying to decide if the next version should be 1.9 or 1.8x and
what other changes need to go in.

* Adds noexcept specifiers to the move special members of xml_document, but only #ifndef PUGIXML_COMPACT

* Adds a macro definition to be able to use noexcept with supporting compilers

* Adds noexcept specifier to move special members of xpath_node_set, xpath_variable_set and xpath_query, but not of xml_document as it has a throwing implementation

Enables usage of override specifier for MSVC compilers

Enables usage of override specifier for MSVC compilers (beginning with 17.0 which is the compiler of Visual Studio 2012)

Texas Instruments compiler produces this warning for unused template
member functions:

	"pugixml.cpp", line 253: warning #179-D: function
	"pugi::impl::<unnamed>::auto_deleter<T>::release [with
	T=pugi::impl::<unnamed>::xml_stream_chunk<char>]" was declared but
	never referenced

As far as I can tell, this is a compiler issue - these functions should
not be instantiated in the first place; while it's possible to rework
the code to work around this, the changes would be fragile. It seems
best to just disable this warning - we've seen something similar on SNC
(which appears to use the same frontend!..).

Fixes #182.

It looks like there are several cases where this might happen:

- In some MinGW distributions, the LLONG_MIN/etc defines are guarded
with:

	#if !defined(__STRICT_ANSI__) && defined(__GNUC__)

Which means that you don't get them in strict ANSI mode. The previous
workaround was specifically targeted towards this.

- In some GCC distributions (notably GCC 6.3.0 in some configurations),
LLONG_MIN/etc. defines are guarded with:

	#if (defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L)

But __STDC_VERSION__ isn't defined as C99 even if you use -std=c++14 -
which is probably technically valid, but not useful.

To work around this, redefine the symbols whenever we are building with
GCC and we need them and they aren't defined - doing this is better than
not building. Instead of hard-coding the constants, use GCC-specific
__LONG_LONG_MAX__ to compute them.

Fixes #181.

Cmake touchups

<mesh> node attribute name is "name", not "mesh".

tests: Fix OSX test failure

Apparently at some point OSX behavior when reading /dev/tty switched
from "can't open the file" to "the file can be opened and 0 bytes can be
read from it" which generates a wrong error and doesn't exercise the
code path we care about.

Fixes #176.

This makes it a bit faster and matches other internal code better.

The static_buffer optimization seems to come from the time where the
on-heap buffer was allocated using global memory operations. At this
point the temporary buffer and temporary string storage all come from
the evaluation stack (that can be partially allocated on heap...), so
the extra logic isn't relevant for performance.

This change implements move ctor and assign support for xml_document.

All node handles remain valid after the move and point to the new document; the only exception is the document node itself (that remains unmoved).

Move is O(document size) in theory because it needs to relocate immediate document children (there is just one in conformant documents) and all memory pages; in practice the memory pages only need the header adjusted, which is ~0.1% of the actual data size.

Move requires no allocations in general, except when using compact mode where some moves need to grow the hash table which can fail (throw).

Fixes #104

This helps make sure our error handling logic works and is exercised.

In compact mode, we currently can not support zero-allocation moves
since some pointer assignments required during the move need to allocate
hash table slots.

This is mostly applicable to xml_document_struct::first_child, since the
pointer to this element is used as a hash table key, but there are some
contrived cases where parents of root's children need a hash slot and
didn't have it before.

These cases can be fixed by changing the compact encoding to be a bit
more move friendly, but for now it's easier to handle the error and
throw/return during move.

When this happens, the source document doesn't change.

This allows us to do a single reserve for a known amount of assignments
that is larger than the default minimum per reserve (16).

This makes sure that MSVC shared library build actually exports all the
needed symbols and generates import table.

Somehow, this is actually enough to make pugixml link as a DLL - there's
no need to specify __declspec(dllimport) even though pugixml exports
classes via DLL.

Fixes #113.

This warning is new as of GCC 7 and highlights undefined behavior in the
preprocessor that ASAN detection was relying on.

These days OSX clang supports UB sanitizer so we can just use the same
settings for all systems.

The old fuzzer location is deprecated; this also makes it almost trivial
to fuzz, provided that the clang is set up correctly... on Ubuntu 17.10,
a command sequence like this works now:

    sudo apt install clang-5.0
    sudo apt install libfuzzer-5.0
    sudo cp /usr/lib/llvm-5.0/lib/libFuzzer.a /usr/lib/libLLVMFuzzer.a
    CXX=clang++-5.0 make fuzz_parse

These tests currently fail for compact mode because of ->reserve()
failing.

After move some nodes in the hash table can have keys that point to
other; this makes the table somewhat larger but this does not impact
correctness.

The reason is that for us to access a key in the hash table, there
should be a compact_pointer/string object with the state indicating that
it is stored in a hash table, and with the address matching the key. For
this to happen, we had to have put this object into this state which
would mean that we'd overwrite the hash entry with the new, correct
value.

When nodes/pages are being removed, we do not clean up keys from the
hash table - it's safe for the same reason, and thus move doesn't
introduce additional contracts here.

We now check that appending a child to a moved document performs no
allocations - this is already the case, but if we neglected to copy the
allocator state this test would fail.

Large test wasn't testing shared parent condition properly - add one
more level of hierarchy so that it works as expected.

Add a test that checks that static buffer pointer was moved correctly
by checking if offset_debug still works.

Make sure we have coverage for empty documents and for large documents
that trigger compact_shared_parent != root for some pages.

Verify that move doesn't allocate and that it preserves structures
required for tree memory management and append_buffer in tact.

These just verify that move ctor/assignment operator work as expected in
simple cases - there are a number of ways in which the internal
structure can be incorrect...

This change implements the initial version of move construction and
assignment support for documents.

When moving a document to another document, we always make sure move
target is in "clean" state (empty document), and proceed by relocating
all structures in the most efficient way possible.

Complications arise from the fact that the root (document) node is
embedded into xml_document object, so all pointers to it have to change;
this includes parent pointers of all first-level children as well as
allocator pointers in all memory pages and previous pointer in the first
on-heap memory page.

Additionally, compact mode makes everything even more complicated
because some of the pointers we need to update are stored in the hash
table (in fact, document first_child pointer is very likely to be there;
some parent pointers in first-level children will be using
compact_shared_parent but some won't be) which requires allocating a new
hash table which can fail.

Some details of this process are not fully fleshed out, especially for
compact mode; and this definitely requires many tests.

It has always been the case that pugixml does not perform Unicode
validation or name/tag Unicode character class validation, but it wasn't
very obvious from documentation.

Fixes #162

We support Latin-1 and automatically detect it by parsing the encoding
from document declaration; both of these were omitted from the
description of the automatic detection.

Additionally, the description has been rewritten to be more concise and
a bit more abstract - there's no need to specify the algorithm precisely
here.

Fixes #158.