Add latest Erlang VMs to the test matrix

Remove flaky test case

This test has proved its point and now just exists to randomly fail some
builds depending on race conditions with the garbage collector.

Fix map type spec

I was being lazy and relying on Travis. This fixes up the map spec for
newer VMs.

Add map typespec for dialyzer

This obviously only exists on VMs that support it.

Strings can be atoms or binaries

Fix dialyzer type specs

Revamp yields back to Erlang

In the original PR for `return_trailer` @vlm pointed out that I wasn't
using enif_consume_timeslice correctly. This fixes that by changing out
its called.

Previously we attempted to define the total number of bytes to decode or
encode in a single NIF call and then would consume as much of the
timeslice as we processed. This is wrong because we may start the NIF
call with less than an entire timeslice left.

The new approach is to define the number of bytes to encode or decode
per reduction and then iteratively call enif_consume_timeslice until it
indicates that we should return.

Add new return_trailer option

Previously Jiffy would throw an error about trailing data if there is
any non-whitespace character encounter after the first term had been
decoded.

This patch adds a decoder option `return_trailer` that will instead
return a sub-binary starting at the first non-whitespace character. This
allows users to be able to decode multiple terms from a single iodata()
term.

Thanks to @vlm for the original patch.

Ignore test XML files

Merge pull request #65 from lpgauth/no_native

Add compile option no_native

Add Dialyzer types and specs

Thanks to @joedevivo for the contribution.

Fixes #85

Squash to new double-conversion

Document new encoding and decoding options

Update double-conversion to latest master

Fix typo in README.md

Thanks to @dvliman and @kxepal for noticing.

Merge pull request #93 from ratelle/master

Add replace_undefined and escape_forward_slashes

Add an option to escape forward slashes

This brings back escaping forward slashes as an option during encoding.
Default is still not to escape.

Add an option to control null value decoding atom

This is pretty much a generalisation of the use_nil option to support an
arbitrary atom.

Merge pull request #92 from emfa/master

Changed pos to unsigned int to prevent warning from happening.

Changed pos to unsigned int to prevent warning from happening.

Merge pull request #86 from clonejo/patch-1

update README.md fixing typo in maps example

update README.md fixing typo in maps example

Merge pull request #78 from tuncer/rebar.config-windows

rebar.config: fix Windows support (CFLAGS, CXXFLAGS)

rebar.config: fix Windows support (CFLAGS, CXXFLAGS)

Account for char possibly being unsigned

This sounds rather insane to me but I've managed to show that `(char)
-1` is converted to 255 on some platforms. This was reproduced on
ppc64el via Qemu on OS X. A simple program that does `fprintf(stderr,
"%d\r\n", (char) -1);` prints 255 to the console. Rather than rely on
the signedness of a char I've just updated things to use an unsigned
char (which hopefully is never signed) and replaced -1 with 255 for the
sentinel value when converting hex values.

Thanks to Balint Reczey (@rbalint) for the report.

Fixes #74

Travis.ci added support for Erlang 17.1

Fix memory leak when encoding bare bignums

This fixes a leak when encoding a bare bignum. Technically it would be
possible to hit this memory leak randomly with bignums in objects but
the chances are highly unlikely.

Thanks to @miriampena for the issue.

Fixes #69

Remove unnecessary inclusion of proper.hrl

Persist the `val` register across yield

The `val` variable is a register value that we need to be able to return
at any time from `decode_iter`. If it happened that a yield was
triggered while processing trailing whitespace the lack of persistance
caused decode to return a term intialized from a random integer value.
Obviously the Erlang VM did not enjoy this.

Thanks to @michalpalka for the report.

Fixes #66

Improved encoder errors

This updates encoder errors to report the actual Erlang value that
caused the error. This should make it easier to debug errors when
generating JSON.

Tweak the nil encoding logic

I must've managed to miss the PR update from Stanislav the other day
when merging this.

Improved Elixir compatibility

This implements the `use_nil` option as discussed on issue #64. Passing
the atom `use_nil` as an option to both encode and decode will replace
the atom `null` with `nil` when decoding and encode `nil` as `null` when
encoding values.

Fixes #64
Fixes #68

Add compile option no_native

Avoid uint64 for 32bit compatibility

Rather than worry about truncation casting from a possibly 64bit value
down to a possibly 32bit size_t we just limit the total bytes per
invocation to 4G using an unsigned integer.

Thanks to @seriyps for the report.

Fixes #61

Disable strict aliasing

This is motivated by issue #60 to see if we can get away with `-O3`
while still handling the cast of a `Decoder**` to `void**`.

Fixes #60

Be explicit on the stdlib dependency

Update optimization flags

Include documentation on the maps feature

Fix timeouts for short doubles

Timeouts apparently don't actually work unless you use a test generator.
Which makes sense in hindsight.

Silence unused function compiler warnings

Include the Travis-CI status badge in the README

Adjust timeouts to a sane cutoff

Remove etap target from the Makefile

Make sure to update the config for Travis-CI

Enable Travis-CI builds

Replace etap with eunit for the test suite

Finally got off my butt and started using EUnit.

Be specific enough that =:= returns true

Refactoring the test suite I found that the old etap was only as strict
as the `==` operator where as EUnit uses the `=:=` operator.

Initial support for the new map type

This patch adds initial support for decoding/encoding to/from the new
maps data type.

I'd like to thank Jihyun Yu (yjh0502) for the initial versions of this
work.

Expand the README to cover the API more clearly

Minor README.md grammar correction.

Yield back to Erlang while encoding JSON

This adds a configurable limit on the number of bytes produced by
the encoder before yielding back to the Erlang VM. This is to avoid the
infamous scheduler collapse issues.

The `jiffy:encode/2` now takes an option `{bytes_per_iter,
pos_integer()}` that controls the yield frequency. The default value is
2048.

Yield back to Erlang while decoding JSON

This adds a configurable limit on the number of bytes consumed by
the decoder before yielding back to the Erlang VM. This is to avoid the
infamous scheduler collapse issues.

The `jiffy:decode/2` now takes an option `{bytes_per_iter,
pos_integer()}` that controls the yield frequency. The default value is
2048.

Use a resource for the encoder structure

This is ground work to allow Jiffy to yield back to the scheduler.
Creating an encoder resource will allow for the necessary state to be
carried across NIF function invocations.

Use a resource for the decoder structure

This is ground work to allow Jiffy to yield back to the scheduler.
Creating a decoder resource will allow for the necessary state to be
carried across NIF function invocations.

Allow the use of GDB/LLDB for debugging

If the environment variable USE_GDB exists this plugin will pause
before the EUNIT tests so that you can attach a debugger to the VM.

Silence the dev marker command

Ignore erln8.config

Noncharacters U+FFFF and U+FFFE are not invalid.
Properly decode them and accept to encode them.

This was clarified by Unicode Technical Committee:
http://www.unicode.org/versions/corrigendum9.html

Add check for below array bounds

Signed-off-by: Nobuhiro Iwamatsu <iwamatsu@nigauri.org>

__GNUC__ is a better choice than __GCC__

Signed-off-by: Nobuhiro Iwamatsu <iwamatsu@nigauri.org>

Fix typo in utils.h

Signed-off-by: Nobuhiro Iwamatsu <iwamatsu@nigauri.org>

Prevent segfaults on unterminated strings

A single quote input was causing segfaults due to sneaking past the
string termination logic. This patch corrects that lapse in conditional
by only parsing strings where a closing quote was found. All other
strings are rejected as invalid.

Big thanks to Jean-Charles Campagne (@jccampagne) for reporting the
issue.

Fix compilation on GCC 4.8

Minor change for building on Windows

Turn on compiler optimizations

Because reasons.

Forgot to refactor the roundtrip tests

I removed some columns to try and minimize the amount of test data I'm
requiring and forgot to update the test code.

Add tests from double-conversion library

I pulled in a lot of tests from the double-conversion test suite to make
sure we don't accidentally break behavior in the future.

Bug fix for large doubles with a fraction

My truth table was a bit busted for extreme value doubles.

Check in the double-conversion dependency

While using rebar's dependency management was surprisingly easy it
broke apps that tried to build Jiffy as a dependency due to relative
path #includes.

This also fixes a few other issues. Most notably it removes the use of
the ECMAScript compatible encoding due to JSON's lack of support for +/-
Inf and NaN.

Encode floating point numbers as short as possible

Floating point numbers are no longer encoded as a one to one mapping
of their binary representation, but as short as possible (while still
being acurate). The double-conversion library [1] is used to do the
hard work.

The ECMAScript compatible conversion is used.

[1] https://code.google.com/p/double-conversion/

Remove some old cruft from rebar.config

I must've originally copied this config from Emonk.

No longer escape forward slashes

After a few requests and some reflection I've decided to stop escaping
forward slashes in strings while still accepting the escaped version
through the decoder. This appears to mimic the behavior of other popular
JSON libraries I've checked (Ruby and Python).

Remove stray while loop

Apparently I missed this when refactoring a do/while loop into a
standard while loop. It was a harmless extra invocation to check if the
stack was empty.

Adjust rebar.config to support rebar v2.0

- Include Windows preprocessor definitions that rebar is missing
- Minor changes to optimisation flags

Make PropEr a soft dependency

This prevents applications that depend on Jiffy from requiring PropEr as
a dependency just to run Jiffy's full test suite. If you want to run the
full test suite you'll have to run Jiffy's Makefile directly which
creates a `.jiffy.dev` marker that enables the full test suite.

Normalize whitespace in Makefile

Add PHONY targets for safety

Just trying to be a bit more thorough in the Makefile targets.

Add a distclean target for Make

This runs a `git clean -fxd` to revert to a pristine Git clone.

Use the Git protocol for PropEr

I've had reports that HTTPS seems to fail a bit more often than the Git
URLs. I've seen this before as well so I've gone ahead and switched
protocols for the clone.

Fix code reloading for Jiffy

As it turns out I did not understand the documenation for
load/upgrade/unload correctly. load/upgrade are called conditionally if
there's code in the VM for the NIF. Ie, no code means load is called,
where as if code exists, upgrade is called.

unload is called regardless once per load/unload. This means that
load/upgrade in Jiffy's case will each create a state object and unload
will free it each time. I was missing the fact that unload is called
every time and hence I don't need to clear the state in upgrade.

Be paranoid about the values sent to upgrade

The docs aren't entirely clear on the order of calls for upgrades so
this is mostly just in case old_priv ever happens to not be what load
returned in priv.

Fix hot code upgrades

Fix compiler warning for gcc 4.4.3

Update rebar to 2.0.0

Add an option to ignore UTF-8 encoding errors

By default Jiffy is quite strict in what it encodes. By default it will
not allow invalid UTF-8 to be produced. This can cause issues when
attempting to encode JSON that was decoded by other libraries as UTF-8
semantics are not uniformly enforced.

This patch adds an option 'force_utf8' to the encoder. If encoding hits
an error for an invalid string it will forcefully mutate the object to
contain only valid UTF-8 and return the resulting encoded JSON.

For the most part this means it will strip any garbage data from
binaries replacing it replacement codepoint U+FFFD. Although, it will
also try and the common error of encoding surrogate pairs as three-byte
sequences and reencode them into UTF-8 properly.

Update rebar and the Makefile

  * Update rebar to a more recent version
  * Update rebar.config for deprecation warnings
  * Allow people to export the REBAR environment variable to use
    their own version of rebar
  * Fixed `make clean`

Windows: MSVC compatibility

Fix segfaul when encoding with the uescape option

There was a bug that was resetting the extra amount of space needed when
encoding unicode characters with the `uescape` option enabled.

Cleanup Makefile

Fix silly error in the README

Fix uescapes for combining characters

I had a silly direction mistake in a bit shift that was causing the high
portion of all combining characters to be printed as \uD800 which is
obviously wrong. This bug only affects people using the non-default
uescape option during encoding.

Updated rebar to latest master

Ensure that encoded doubles have a decimal point

Numbers like 1.0 were being encoded as <<"1">> which can lead to a bit
of confusion. This merely checks if a decimial point exists and if not
it appends ".0" to the value.

Allow iolists to be passed directly to decode/1

Fixes #15

Add pretty print

jiffy:encode/2 now accepts a 'pretty' option that will format the JSON
output using two-space indents.

Reduce PropEr test size for speed

I need to fix this so that object sizes don't explode when generating
larger values. Basically, as the type generator recurses is should be
adjusting the size value.

Avoid false dialyzer warnings by using erlang:nif_error/1

clean test/*.beam

Adjust number ranges to show bignum support

Looks like there's a slight difference in the number of significant
digits supported across platforms in strtod. This just adds a couple to
force it into the bignum code.

Limit test case in the interest of speed