Add: julia-0.6.2

Former-commit-id: ccc667cf67d569f3fb3df39aa57c2134755a7551
2018-02-10 10:27:19 -07:00 · 2018-02-10 10:27:19 -07:00 · 019f8e3064
commit 019f8e3064
parent 94220957d7
723 changed files with 276164 additions and 0 deletions
--- a/julia-0.6.2/LICENSE.md
+++ b/julia-0.6.2/LICENSE.md
@ -0,0 +1,94 @@
+The Julia language is licensed under the MIT License. The "language" consists
+of the compiler (the contents of src/), most of the standard library (base/),
+and some utilities (most of the rest of the files in this repository). See below
+for exceptions.
+
+> Copyright (c) 2009-2016: Jeff Bezanson, Stefan Karpinski, Viral B. Shah,
+> and other contributors:
+>
+> https://github.com/JuliaLang/julia/contributors
+>
+> Permission is hereby granted, free of charge, to any person obtaining
+> a copy of this software and associated documentation files (the
+> "Software"), to deal in the Software without restriction, including
+> without limitation the rights to use, copy, modify, merge, publish,
+> distribute, sublicense, and/or sell copies of the Software, and to
+> permit persons to whom the Software is furnished to do so, subject to
+> the following conditions:
+>
+> The above copyright notice and this permission notice shall be
+> included in all copies or substantial portions of the Software.
+>
+> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+> EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+> MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+> NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+> LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+> OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+> WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+Julia includes code from the following projects, which have their own licenses:
+
+- [crc32c.c](http://stackoverflow.com/questions/17645167/implementing-sse-4-2s-crc32c-in-software) (CRC-32c checksum code by Mark Adler) [[ZLib](https://opensource.org/licenses/Zlib)].
+- [LDC](https://github.com/ldc-developers/ldc/blob/master/LICENSE) (for ccall/cfunction ABI definitions) [BSD-3]. The portion of code that Julia uses from LDC is [BSD-3] licensed.
+- [LLVM](http://releases.llvm.org/3.9.0/LICENSE.TXT) (for parts of src/jitlayers.cpp and src/disasm.cpp) [BSD-3, effectively]
+- [MUSL](http://git.musl-libc.org/cgit/musl/tree/COPYRIGHT) (for getopt implementation on Windows) [MIT]
+- [MINGW](https://sourceforge.net/p/mingw/mingw-org-wsl/ci/legacy/tree/mingwrt/mingwex/dirname.c) (for dirname implementation on Windows) [MIT]
+- [NetBSD](http://www.netbsd.org/about/redistribution.html) (for setjmp, longjmp, and strptime implementations on Windows) [BSD-3]
+- [Python](https://docs.python.org/2/license.html) (for strtod implementation on Windows) [BSD-3, effectively]
+- [randmtzig.c](https://github.com/JuliaLang/julia/blob/master/test/perf/micro/randmtzig.c) for Gaussian random number generation (for C benchmarks only) [BSD-3]
+
+The Julia language links to the following external libraries, which have their
+own licenses:
+
+- [FEMTOLISP](https://github.com/JeffBezanson/femtolisp) [BSD-3]
+- [LIBUNWIND](http://git.savannah.gnu.org/gitweb/?p=libunwind.git;a=blob_plain;f=LICENSE;hb=master) [MIT]
+- [LIBUV](https://github.com/joyent/libuv/blob/master/LICENSE) [MIT]
+- [LLVM](http://releases.llvm.org/3.9.0/LICENSE.TXT) [BSD-3, effectively]
+- [UTF8PROC](https://github.com/JuliaLang/utf8proc) [MIT]
+
+
+Julia's standard library uses the following external libraries, which have
+their own licenses:
+
+- [ARPACK](http://www.caam.rice.edu/software/ARPACK/RiceBSD.txt#LICENSE) [BSD-3]
+- [DSFMT](http://www.math.sci.hiroshima-u.ac.jp/~m-mat/MT/SFMT/LICENSE.txt) [BSD-3]
+- [OPENLIBM](https://github.com/JuliaLang/openlibm/blob/master/LICENSE.md) [MIT, BSD-2, ISC]
+- [OPENSPECFUN](https://github.com/JuliaLang/openspecfun) [MIT, public domain]
+- [FADDEEVA](http://ab-initio.mit.edu/Faddeeva) [MIT]
+- [FFTW](http://fftw.org/doc/License-and-Copyright.html) [GPL2+]
+- [GMP](http://gmplib.org/manual/Copying.html#Copying) [LGPL3+ or GPL2+]
+- [LIBGIT2](https://github.com/libgit2/libgit2/blob/development/COPYING) [GPL2+ with unlimited linking exception]
+- [CURL](https://curl.haxx.se/docs/copyright.html) [MIT/X derivative]
+- [LIBSSH2](https://github.com/libssh2/libssh2/blob/master/COPYING) [BSD-3]
+- [MBEDTLS](https://tls.mbed.org/how-to-get) [either GPLv2 or Apache 2.0]
+- [MPFR](http://www.mpfr.org/mpfr-current/mpfr.html#Copying) [LGPL3+]
+- [OPENBLAS](https://raw.github.com/xianyi/OpenBLAS/master/LICENSE) [BSD-3]
+- [LAPACK](http://netlib.org/lapack/LICENSE.txt) [BSD-3]
+- [PCRE](http://www.pcre.org/licence.txt) [BSD-3]
+- [SUITESPARSE](http://faculty.cse.tamu.edu/davis/suitesparse.html) [mix of LGPL2+ and GPL2+; see individual module licenses]
+
+
+The following components of Julia's standard library have separate licenses:
+
+- base/grisu/* (see [double-conversion](https://github.com/google/double-conversion/blob/master/LICENSE))
+- base/sparse/umfpack.jl (see [SUITESPARSE](http://faculty.cse.tamu.edu/davis/suitesparse.html))
+- base/sparse/cholmod.jl (see [SUITESPARSE](http://faculty.cse.tamu.edu/davis/suitesparse.html))
+- base/special/exp.jl (see [FREEBSD MSUN](https://github.com/freebsd/freebsd) [FreeBSD/2-clause BSD/Simplified BSD License])
+
+
+Julia's build process uses the following external tools:
+
+- [PATCHELF](http://hydra.nixos.org/build/1524660/download/1/README)
+- [OBJCONV](http://www.agner.org/optimize/#objconv)
+
+
+Julia bundles the following external programs and libraries on some platforms:
+
+- [7-Zip](http://www.7-zip.org/license.txt)
+- [BUSYBOX](https://github.com/rmyorston/busybox-w32/blob/master/LICENSE)
+- [ZLIB](http://zlib.net/zlib_license.html)
+- [LIBEXPAT](http://expat.cvs.sourceforge.net/viewvc/expat/expat/README)
+
+On some platforms, distributions of Julia contain SSL certificate authority certificates,
+released under the [Mozilla Public License](https://en.wikipedia.org/wiki/Mozilla_Public_License).
--- a/julia-0.6.2/bin/julia
+++ b/julia-0.6.2/bin/julia
--- a/julia-0.6.2/bin/julia-debug
+++ b/julia-0.6.2/bin/julia-debug
--- a/julia-0.6.2/etc/julia/juliarc.jl
+++ b/julia-0.6.2/etc/julia/juliarc.jl
@ -0,0 +1,3 @@
+# This file should contain site-specific commands to be executed on Julia startup
+# Users may store their own personal commands in the user home directory `homedir()`, in a file named `.juliarc.jl`
+
--- a/julia-0.6.2/include/julia/END.h
+++ b/julia-0.6.2/include/julia/END.h
@ -0,0 +1,55 @@
+/*-
+ * Copyright (c) 1990 The Regents of the University of California.
+ * All rights reserved.
+ *
+ * This code is derived from software contributed to Berkeley by
+ * William Jolitz.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 4. Neither the name of the University nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
+ *      from: @(#)DEFS.h        5.1 (Berkeley) 4/23/90
+ * $FreeBSD: src/sys/i386/include/asm.h,v 1.14 2007/08/22 04:26:07 jkoshy Exp $
+ */
+
+#if defined(__linux__) || defined(__FreeBSD__) || defined(__ELF__)
+.size CNAME, . - CNAME
+#else
+#ifndef _MSC_VER
+.end
+#else
+CNAME endp
+end
+#endif
+#endif
+
+#undef CNAME
+#undef HIDENAME
+#undef STR
+#undef XSTR
+#undef _START_ENTRY
+#ifndef __APPLE__
+#undef EXT_
+#undef EXT
+#endif
--- a/julia-0.6.2/include/julia/ENTRY.amd64.h
+++ b/julia-0.6.2/include/julia/ENTRY.amd64.h
@ -0,0 +1,75 @@
+/*-
+ * Copyright (c) 1990 The Regents of the University of California.
+ * All rights reserved.
+ *
+ * This code is derived from software contributed to Berkeley by
+ * William Jolitz.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 4. Neither the name of the University nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
+ *      from: @(#)DEFS.h        5.1 (Berkeley) 4/23/90
+ * $FreeBSD: src/sys/amd64/include/asm.h,v 1.18 2007/08/22 04:26:07 jkoshy Exp $
+ */
+
+#define _START_ENTRY .p2align 4,0x90
+#define STR(csym)           #csym
+#define XSTR(csym)          STR(csym)
+#if defined(__linux__) || defined(__FreeBSD__) || defined(__ELF__)
+#ifndef __APPLE__
+#define EXT_(csym)          csym
+#define EXT(csym)           EXT_(csym)
+#endif
+#define HIDENAME(asmsym)    .asmsym
+.text
+_START_ENTRY
+.globl EXT(CNAME)
+.type EXT(CNAME),@function
+EXT(CNAME):
+
+#elif defined(_WIN32)
+#define EXT_(csym)          csym
+#define EXT(csym)           EXT_(csym)
+#define HIDENAME(asmsym)    .asmsym
+
+#ifndef _MSC_VER
+.intel_syntax noprefix
+.text
+_START_ENTRY
+.globl EXT(CNAME)
+.section .drectve
+.ascii " -export:"
+.ascii XSTR(CNAME)
+.section .text
+.def EXT(CNAME)
+.scl 2
+.type 32
+.endef
+EXT(CNAME):
+#else
+.code
+CNAME proc
+#endif
+
+#endif
--- a/julia-0.6.2/include/julia/ENTRY.i387.h
+++ b/julia-0.6.2/include/julia/ENTRY.i387.h
@ -0,0 +1,76 @@
+/*-
+ * Copyright (c) 1990 The Regents of the University of California.
+ * All rights reserved.
+ *
+ * This code is derived from software contributed to Berkeley by
+ * William Jolitz.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 4. Neither the name of the University nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
+ *      from: @(#)DEFS.h        5.1 (Berkeley) 4/23/90
+ * $FreeBSD: src/sys/i386/include/asm.h,v 1.14 2007/08/22 04:26:07 jkoshy Exp $
+ */
+
+#define _START_ENTRY .p2align 2,0x90
+#define STR(csym)           #csym
+#define XSTR(csym)          STR(csym)
+#if defined(__linux__) || defined(__FreeBSD__) || defined(__ELF__)
+#ifndef __APPLE__
+#define EXT_(csym)          csym
+#define EXT(csym)           EXT_(csym)
+#endif
+#define HIDENAME(asmsym)    .asmsym
+.text
+_START_ENTRY
+.globl EXT(CNAME)
+.type EXT(CNAME),@function
+EXT(CNAME):
+
+#elif defined(_WIN32)
+#define EXT_(csym)          _##csym
+#define EXT(csym)           EXT_(csym)
+#define HIDENAME(asmsym)    .asmsym
+
+#ifndef _MSC_VER
+.intel_syntax
+.text
+_START_ENTRY
+.globl EXT(CNAME)
+.section .drectve
+.ascii " -export:", XSTR(CNAME)
+.section .text
+.def EXT(CNAME)
+.scl 2
+.type 32
+.endef
+EXT(CNAME):
+#else
+.586
+.model small,C
+.code
+CNAME proc
+#endif
+
+#endif
--- a/julia-0.6.2/include/julia/MurmurHash3.h
+++ b/julia-0.6.2/include/julia/MurmurHash3.h
@ -0,0 +1,22 @@
+//-----------------------------------------------------------------------------
+// MurmurHash3 was written by Austin Appleby, and is placed in the public
+// domain. The author hereby disclaims copyright to this source code.
+
+#ifndef MURMURHASH3_H
+#define MURMURHASH3_H
+
+//-----------------------------------------------------------------------------
+// Platform-specific functions and macros
+#include <stdint.h>
+
+//-----------------------------------------------------------------------------
+
+void MurmurHash3_x86_32  ( const void * key, int len, uint32_t seed, void * out );
+
+void MurmurHash3_x86_128 ( const void * key, int len, uint32_t seed, void * out );
+
+void MurmurHash3_x64_128 ( const void * key, int len, uint32_t seed, void * out );
+
+//-----------------------------------------------------------------------------
+
+#endif // MURMURHASH3_H
--- a/julia-0.6.2/include/julia/arraylist.h
+++ b/julia-0.6.2/include/julia/arraylist.h
@ -0,0 +1,30 @@
+// This file is a part of Julia. License is MIT: https://julialang.org/license
+
+#ifndef ARRAYLIST_H
+#define ARRAYLIST_H
+
+#define AL_N_INLINE 29
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct {
+    size_t len;
+    size_t max;
+    void **items;
+    void *_space[AL_N_INLINE];
+} arraylist_t;
+
+arraylist_t *arraylist_new(arraylist_t *a, size_t size);
+void arraylist_free(arraylist_t *a);
+
+void arraylist_push(arraylist_t *a, void *elt);
+void *arraylist_pop(arraylist_t *a);
+void arraylist_grow(arraylist_t *a, size_t n);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
--- a/julia-0.6.2/include/julia/bitvector.h
+++ b/julia-0.6.2/include/julia/bitvector.h
@ -0,0 +1,22 @@
+// This file is a part of Julia. License is MIT: https://julialang.org/license
+
+#ifndef BITVECTOR_H
+#define BITVECTOR_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+JL_DLLEXPORT uint32_t *bitvector_new(uint64_t n, int initzero);
+JL_DLLEXPORT
+uint32_t *bitvector_resize(uint32_t *b, uint64_t oldsz, uint64_t newsz,
+                           int initzero);
+size_t bitvector_nwords(uint64_t nbits);
+JL_DLLEXPORT void bitvector_set(uint32_t *b, uint64_t n, uint32_t c);
+JL_DLLEXPORT uint32_t bitvector_get(uint32_t *b, uint64_t n);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
--- a/julia-0.6.2/include/julia/crc32c.h
+++ b/julia-0.6.2/include/julia/crc32c.h
@ -0,0 +1,19 @@
+// This file is a part of Julia. License is MIT: https://julialang.org/license
+
+#ifndef CRC32C_H
+#define CRC32C_H 1
+
+#include "dtypes.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+JL_DLLEXPORT void jl_crc32c_init(int force_sw);
+JL_DLLEXPORT uint32_t jl_crc32c(uint32_t crc, const void *buf, size_t len);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* CRC32C_H */
--- a/julia-0.6.2/include/julia/dirpath.h
+++ b/julia-0.6.2/include/julia/dirpath.h
@ -0,0 +1,20 @@
+// This file is a part of Julia. License is MIT: https://julialang.org/license
+
+#ifndef DIRPATH_H
+#define DIRPATH_H
+
+#ifdef _OS_WINDOWS_
+#define PATHSEPSTRING "\\"
+#define PATHLISTSEPSTRING ";"
+#if defined(_MSC_VER) || defined(_COMPILER_CLANG_)
+#define PATH_MAX MAX_PATH
+#endif
+#else
+#define PATHSEPSTRING "/"
+#define PATHLISTSEPSTRING ":"
+#ifndef PATH_MAX // many platforms don't have a max path, we define one anyways
+#define PATH_MAX 1024
+#endif
+#endif
+
+#endif
--- a/julia-0.6.2/include/julia/dtypes.h
+++ b/julia-0.6.2/include/julia/dtypes.h
@ -0,0 +1,217 @@
+// This file is a part of Julia. License is MIT: https://julialang.org/license
+
+#ifndef DTYPES_H
+#define DTYPES_H
+
+#include <stddef.h>
+#include <stddef.h> // double include of stddef.h fixes #3421
+#include <stdint.h>
+#if defined(_COMPILER_INTEL_)
+#include <mathimf.h>
+#else
+#include <math.h>
+#endif
+
+#include "platform.h"
+
+#if !defined(_OS_WINDOWS_)
+#include <inttypes.h>
+#endif
+
+#if defined(_OS_WINDOWS_)
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <sys/stat.h>
+
+#if !defined(_COMPILER_MINGW_)
+
+#define strtoull                                            _strtoui64
+#define strtoll                                             _strtoi64
+#define strcasecmp                                          _stricmp
+#define strncasecmp                                         _strnicmp
+#define snprintf                                            _snprintf
+#define stat                                                _stat
+
+#define STDIN_FILENO                                        0
+#define STDOUT_FILENO                                       1
+#define STDERR_FILENO                                       2
+
+#endif /* !_COMPILER_MINGW_ */
+
+#endif /* _OS_WINDOWS_ */
+
+
+/*
+  This file defines sane integer types for our target platforms. This
+  library only runs on machines with the following characteristics:
+
+  - supports integer word sizes of 8, 16, 32, and 64 bits
+  - uses unsigned and signed 2's complement representations
+  - all pointer types are the same size
+  - there is an integer type with the same size as a pointer
+
+  Some features require:
+  - IEEE 754 single- and double-precision floating point
+
+  We assume the LP64 convention for 64-bit platforms.
+*/
+
+#ifdef _OS_WINDOWS_
+#define STDCALL __stdcall
+# ifdef LIBRARY_EXPORTS
+#  define JL_DLLEXPORT __declspec(dllexport)
+# else
+#  define JL_DLLEXPORT __declspec(dllimport)
+# endif
+#else
+#define STDCALL
+#define JL_DLLEXPORT __attribute__ ((visibility("default")))
+#endif
+
+#ifdef _OS_LINUX_
+#include <endian.h>
+#define LITTLE_ENDIAN  __LITTLE_ENDIAN
+#define BIG_ENDIAN     __BIG_ENDIAN
+#define PDP_ENDIAN     __PDP_ENDIAN
+#define BYTE_ORDER     __BYTE_ORDER
+#endif
+
+#if defined(__APPLE__) || defined(__FreeBSD__)
+#include <machine/endian.h>
+#define __LITTLE_ENDIAN  LITTLE_ENDIAN
+#define __BIG_ENDIAN     BIG_ENDIAN
+#define __PDP_ENDIAN     PDP_ENDIAN
+#define __BYTE_ORDER     BYTE_ORDER
+#endif
+
+#ifdef _OS_WINDOWS_
+#define __LITTLE_ENDIAN    1234
+#define __BIG_ENDIAN       4321
+#define __PDP_ENDIAN       3412
+#define __BYTE_ORDER       __LITTLE_ENDIAN
+#define __FLOAT_WORD_ORDER __LITTLE_ENDIAN
+#define LITTLE_ENDIAN      __LITTLE_ENDIAN
+#define BIG_ENDIAN         __BIG_ENDIAN
+#define PDP_ENDIAN         __PDP_ENDIAN
+#define BYTE_ORDER         __BYTE_ORDER
+#endif
+
+#define LLT_ALLOC(n) malloc(n)
+#define LLT_REALLOC(p,n) realloc((p),(n))
+#define LLT_FREE(x) free(x)
+
+#if defined(_OS_WINDOWS_) && defined(_COMPILER_INTEL_)
+#  define STATIC_INLINE static
+#  define INLINE
+#elif defined(_OS_WINDOWS_) && defined(_COMPILER_MICROSOFT_)
+#  define STATIC_INLINE static __inline
+#  define INLINE __inline
+#else
+#  define STATIC_INLINE static inline
+#  define INLINE inline
+#endif
+
+#if defined(_OS_WINDOWS_) && !defined(_COMPILER_MINGW_)
+#  define NOINLINE __declspec(noinline)
+#  define NOINLINE_DECL(f) __declspec(noinline) f
+#else
+#  define NOINLINE __attribute__((noinline))
+#  define NOINLINE_DECL(f) f __attribute__((noinline))
+#endif
+
+#ifdef _COMPILER_MICROSOFT_
+# ifdef _P64
+#  define JL_ATTRIBUTE_ALIGN_PTRSIZE(x) __declspec(align(8)) x
+# else
+#  define JL_ATTRIBUTE_ALIGN_PTRSIZE(x) __declspec(align(4)) x
+# endif
+#elif defined(__GNUC__)
+#  define JL_ATTRIBUTE_ALIGN_PTRSIZE(x) x __attribute__ ((aligned (sizeof(void*))))
+#else
+#  define JL_ATTRIBUTE_ALIGN_PTRSIZE(x)
+#endif
+
+typedef int bool_t;
+typedef unsigned char  byte_t;   /* 1 byte */
+
+#ifdef _P64
+#define TOP_BIT 0x8000000000000000
+#define NBITS 64
+typedef uint64_t uint_t;  // preferred int type on platform
+typedef int64_t int_t;
+#else
+#define TOP_BIT 0x80000000
+#define NBITS 32
+typedef uint32_t uint_t;
+typedef int32_t int_t;
+#endif
+
+STATIC_INLINE unsigned int next_power_of_two(unsigned int val)
+{
+    /* this function taken from libuv src/unix/core.c */
+    val -= 1;
+    val |= val >> 1;
+    val |= val >> 2;
+    val |= val >> 4;
+    val |= val >> 8;
+    val |= val >> 16;
+    val += 1;
+    return val;
+}
+
+#define LLT_ALIGN(x, sz) (((x) + (sz)-1) & -(sz))
+
+// branch prediction annotations
+#ifdef __GNUC__
+#define __unlikely(x) __builtin_expect(!!(x), 0)
+#define __likely(x)   __builtin_expect(!!(x), 1)
+#else
+#define __unlikely(x) (x)
+#define __likely(x)   (x)
+#endif
+
+#define DBL_MAXINT 9007199254740992LL
+#define FLT_MAXINT 16777216
+#define U64_MAX    18446744073709551615ULL
+#define S64_MAX    9223372036854775807LL
+#define S64_MIN    (-S64_MAX - 1LL)
+#define BIT63      0x8000000000000000LL
+#define U32_MAX    4294967295L
+#define S32_MAX    2147483647L
+#define S32_MIN    (-S32_MAX - 1L)
+#define BIT31      0x80000000
+
+#define D_PNAN ((double)+NAN)
+#define D_NNAN ((double)-NAN)
+#define D_PINF ((double)+INFINITY)
+#define D_NINF ((double)-INFINITY)
+#define F_PNAN ((float)+NAN)
+#define F_NNAN ((float)-NAN)
+#define F_PINF ((float)+INFINITY)
+#define F_NINF ((float)-INFINITY)
+
+typedef enum { T_INT8, T_UINT8, T_INT16, T_UINT16, T_INT32, T_UINT32,
+               T_INT64, T_UINT64, T_FLOAT, T_DOUBLE } numerictype_t;
+
+#define N_NUMTYPES ((int)T_DOUBLE+1)
+
+#ifdef _P64
+# define T_PTRDIFF T_INT64
+# define T_SIZE T_UINT64
+#else
+# define T_PTRDIFF T_INT32
+# define T_SIZE T_UINT32
+#endif
+
+#if defined(__GNUC__) && __GNUC__ >= 7
+#define JL_FALLTHROUGH __attribute__((fallthrough))
+#elif defined(__cplusplus) && defined(__clang_major__) && \
+    defined(__clang_minor__) && (__clang_major__ > 4 || __clang_minor__ >= 5)
+// We require at least clang 3.x
+#define JL_FALLTHROUGH [[clang::fallthrough]]
+#else
+#define JL_FALLTHROUGH
+#endif
+
+#endif /* DTYPES_H */
--- a/julia-0.6.2/include/julia/hashing.h
+++ b/julia-0.6.2/include/julia/hashing.h
@ -0,0 +1,44 @@
+// This file is a part of Julia. License is MIT: https://julialang.org/license
+
+#ifndef HASHING_H
+#define HASHING_H
+
+#include "utils.h"
+#include "dtypes.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+uint_t nextipow2(uint_t i);
+JL_DLLEXPORT uint32_t int32hash(uint32_t a);
+JL_DLLEXPORT uint64_t int64hash(uint64_t key);
+JL_DLLEXPORT uint32_t int64to32hash(uint64_t key);
+#ifdef _P64
+#define inthash int64hash
+#else
+#define inthash int32hash
+#endif
+JL_DLLEXPORT uint64_t memhash(const char *buf, size_t n);
+JL_DLLEXPORT uint64_t memhash_seed(const char *buf, size_t n, uint32_t seed);
+JL_DLLEXPORT uint32_t memhash32(const char *buf, size_t n);
+JL_DLLEXPORT uint32_t memhash32_seed(const char *buf, size_t n, uint32_t seed);
+
+#ifdef _P64
+STATIC_INLINE uint64_t bitmix(uint64_t a, uint64_t b)
+{
+    return int64hash(a^bswap_64(b));
+}
+#else
+STATIC_INLINE uint32_t bitmix(uint32_t a, uint32_t b)
+{
+    return int64to32hash((((uint64_t)a) << 32) | (uint64_t)b);
+}
+#endif
+#define bitmix(a, b) (bitmix)((uintptr_t)(a), (uintptr_t)(b))
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
--- a/julia-0.6.2/include/julia/htable.h
+++ b/julia-0.6.2/include/julia/htable.h
@ -0,0 +1,48 @@
+// This file is a part of Julia. License is MIT: https://julialang.org/license
+
+#ifndef HTABLE_H
+#define HTABLE_H
+
+#define HT_N_INLINE 32
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct {
+    size_t size;
+    void **table;
+    void *_space[HT_N_INLINE];
+} htable_t;
+
+// define this to be an invalid key/value
+#define HT_NOTFOUND ((void*)1)
+
+// initialize and free
+htable_t *htable_new(htable_t *h, size_t size);
+void htable_free(htable_t *h);
+
+// clear and (possibly) change size
+void htable_reset(htable_t *h, size_t sz);
+
+#define HTPROT(HTNAME)                                          \
+void *HTNAME##_get(htable_t *h, void *key);                     \
+void HTNAME##_put(htable_t *h, void *key, void *val);           \
+void HTNAME##_adjoin(htable_t *h, void *key, void *val);        \
+int HTNAME##_has(htable_t *h, void *key);                       \
+int HTNAME##_remove(htable_t *h, void *key);                    \
+void **HTNAME##_bp(htable_t *h, void *key);
+
+#define HTPROT_R(HTNAME)                                                \
+void *HTNAME##_get_r(htable_t *h, void *key, void *ctx);                \
+void HTNAME##_put_r(htable_t *h, void *key, void *val, void *ctx);      \
+void HTNAME##_adjoin_r(htable_t *h, void *key, void *val, void *ctx);   \
+int HTNAME##_has_r(htable_t *h, void *key, void *ctx);                  \
+int HTNAME##_remove_r(htable_t *h, void *key, void *ctx);               \
+void **HTNAME##_bp_r(htable_t *h, void *key, void *ctx);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
--- a/julia-0.6.2/include/julia/ios.h
+++ b/julia-0.6.2/include/julia/ios.h
@ -0,0 +1,214 @@
+// This file is a part of Julia. License is MIT: https://julialang.org/license
+
+#ifndef IOS_H
+#define IOS_H
+
+#include <stdarg.h>
+#include "uv.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+// this flag controls when data actually moves out to the underlying I/O
+// channel. memory streams are a special case of this where the data
+// never moves out.
+
+//make it compatible with UV Handles
+typedef enum { bm_none=UV_HANDLE_TYPE_MAX+1, bm_line, bm_block, bm_mem } bufmode_t;
+typedef enum { bst_none, bst_rd, bst_wr } bufstate_t;
+
+#define IOS_INLSIZE 54
+#define IOS_BUFSIZE 131072
+
+typedef struct {
+    // the state only indicates where the underlying file position is relative
+    // to the buffer. reading: at the end. writing: at the beginning.
+    // in general, you can do any operation in any state.
+    char *buf;        // start of buffer
+
+    int errcode;
+
+#ifdef _P64
+    int _pad_bm;      // put bm at same offset as type field of uv_stream_s
+#endif
+    bufmode_t bm;     //
+    bufstate_t state;
+
+    int64_t maxsize;    // space allocated to buffer
+    int64_t size;       // length of valid data in buf, >=ndirty
+    int64_t bpos;       // current position in buffer
+    int64_t ndirty;     // # bytes at &buf[0] that need to be written
+
+    int64_t fpos;       // cached file pos
+    size_t lineno;    // current line number
+
+    // pointer-size integer to support platforms where it might have
+    // to be a pointer
+    long fd;
+
+    unsigned char readable:1;
+    unsigned char writable:1;
+    unsigned char ownbuf:1;
+    unsigned char ownfd:1;
+    unsigned char _eof:1;
+
+    // this means you can read, seek back, then read the same data
+    // again any number of times. usually only true for files and strings.
+    unsigned char rereadable:1;
+
+    // this enables "stenciled writes". you can alternately write and
+    // seek without flushing in between. this performs read-before-write
+    // to populate the buffer, so "rereadable" capability is required.
+    // this is off by default.
+    //unsigned char stenciled:1;
+
+    // request durable writes (fsync)
+    // unsigned char durable:1;
+
+    int64_t userdata;
+    char local[IOS_INLSIZE];
+} ios_t;
+
+extern void (*ios_set_io_wait_func)(int);
+/* low-level interface functions */
+JL_DLLEXPORT size_t ios_read(ios_t *s, char *dest, size_t n);
+JL_DLLEXPORT size_t ios_readall(ios_t *s, char *dest, size_t n);
+JL_DLLEXPORT size_t ios_write(ios_t *s, const char *data, size_t n);
+JL_DLLEXPORT int64_t ios_seek(ios_t *s, int64_t pos);   // absolute seek
+JL_DLLEXPORT int64_t ios_seek_end(ios_t *s);
+JL_DLLEXPORT int64_t ios_skip(ios_t *s, int64_t offs);  // relative seek
+JL_DLLEXPORT int64_t ios_pos(ios_t *s);  // get current position
+JL_DLLEXPORT int ios_trunc(ios_t *s, size_t size);
+JL_DLLEXPORT int ios_eof(ios_t *s);
+JL_DLLEXPORT int ios_eof_blocking(ios_t *s);
+JL_DLLEXPORT int ios_flush(ios_t *s);
+JL_DLLEXPORT void ios_close(ios_t *s);
+JL_DLLEXPORT int ios_isopen(ios_t *s);
+JL_DLLEXPORT char *ios_take_buffer(ios_t *s, size_t *psize);  // release buffer to caller
+// set buffer space to use
+JL_DLLEXPORT int ios_setbuf(ios_t *s, char *buf, size_t size, int own);
+JL_DLLEXPORT int ios_bufmode(ios_t *s, bufmode_t mode);
+JL_DLLEXPORT int ios_get_readable(ios_t *s);
+JL_DLLEXPORT int ios_get_writable(ios_t *s);
+JL_DLLEXPORT void ios_set_readonly(ios_t *s);
+JL_DLLEXPORT size_t ios_copy(ios_t *to, ios_t *from, size_t nbytes);
+JL_DLLEXPORT size_t ios_copyall(ios_t *to, ios_t *from);
+JL_DLLEXPORT size_t ios_copyuntil(ios_t *to, ios_t *from, char delim);
+JL_DLLEXPORT size_t ios_nchomp(ios_t *from, size_t ntowrite);
+// ensure at least n bytes are buffered if possible. returns # available.
+JL_DLLEXPORT size_t ios_readprep(ios_t *from, size_t n);
+
+/* stream creation */
+JL_DLLEXPORT
+ios_t *ios_file(ios_t *s, const char *fname, int rd, int wr, int create, int trunc);
+JL_DLLEXPORT ios_t *ios_mkstemp(ios_t *f, char *fname);
+JL_DLLEXPORT ios_t *ios_mem(ios_t *s, size_t initsize);
+ios_t *ios_str(ios_t *s, char *str);
+ios_t *ios_static_buffer(ios_t *s, char *buf, size_t sz);
+JL_DLLEXPORT ios_t *ios_fd(ios_t *s, long fd, int isfile, int own);
+// todo: ios_socket
+extern JL_DLLEXPORT ios_t *ios_stdin;
+extern JL_DLLEXPORT ios_t *ios_stdout;
+extern JL_DLLEXPORT ios_t *ios_stderr;
+void ios_init_stdstreams(void);
+
+/* high-level functions - output */
+JL_DLLEXPORT int ios_pututf8(ios_t *s, uint32_t wc);
+JL_DLLEXPORT int ios_printf(ios_t *s, const char *format, ...);
+JL_DLLEXPORT int ios_vprintf(ios_t *s, const char *format, va_list args);
+
+/* high-level stream functions - input */
+JL_DLLEXPORT int ios_getutf8(ios_t *s, uint32_t *pwc);
+JL_DLLEXPORT int ios_peekutf8(ios_t *s, uint32_t *pwc);
+JL_DLLEXPORT char *ios_readline(ios_t *s);
+
+// discard data buffered for reading
+JL_DLLEXPORT void ios_purge(ios_t *s);
+
+/* stdio-style functions */
+#define IOS_EOF (-1)
+JL_DLLEXPORT int ios_putc(int c, ios_t *s);
+//wint_t ios_putwc(ios_t *s, wchar_t wc);
+JL_DLLEXPORT int ios_getc(ios_t *s);
+JL_DLLEXPORT int ios_peekc(ios_t *s);
+//wint_t ios_getwc(ios_t *s);
+int ios_ungetc(int c, ios_t *s);
+//wint_t ios_ungetwc(ios_t *s, wint_t wc);
+#define ios_puts(str, s) ios_write(s, str, strlen(str))
+
+/*
+  With memory streams, mixed reads and writes are equivalent to performing
+  sequences of *p++, as either an lvalue or rvalue. File streams behave
+  similarly, but other streams might not support this. Using unbuffered
+  mode makes this more predictable.
+
+  Note on "unget" functions:
+  There are two kinds of functions here: those that operate on sized
+  blocks of bytes and those that operate on logical units like "character"
+  or "integer". The "unget" functions only work on logical units. There
+  is no "unget n bytes". You can only do an unget after a matching get.
+  However, data pushed back by an unget is available to all read operations.
+  The reason for this is that unget is defined in terms of its effect on
+  the underlying buffer (namely, it rebuffers data as if it had been
+  buffered but not read yet). IOS reserves the right to perform large block
+  operations directly, bypassing the buffer. In such a case data was
+  never buffered, so "rebuffering" has no meaning (i.e. there is no
+  correspondence between the buffer and the physical stream).
+
+  Single-bit I/O is able to write partial bytes ONLY IF the stream supports
+  seeking. Also, line buffering is not well-defined in the context of
+  single-bit I/O, so it might not do what you expect.
+
+  implementation notes:
+  in order to know where we are in a file, we must ensure the buffer
+  is only populated from the underlying stream starting with p==buf.
+
+  to switch from writing to reading: flush, set p=buf, cnt=0
+  to switch from reading to writing: seek backwards cnt bytes, p=buf, cnt=0
+
+  when writing: buf starts at curr. physical stream pos, p - buf is how
+  many bytes we've written logically. cnt==0
+
+  dirty == (bitpos>0 && state==iost_wr), EXCEPT right after switching from
+  reading to writing, where we might be in the middle of a byte without
+  having changed it.
+
+  to write a bit: if !dirty, read up to maxsize-(p-buf) into buffer, then
+  seek back by the same amount (undo it). write onto those bits. now set
+  the dirty bit. in this state, we can bit-read up to the end of the byte,
+  then formally switch to the read state using flush.
+
+  design points:
+  - data-source independence, including memory streams
+  - expose buffer to user, allow user-owned buffers
+  - allow direct I/O, don't always go through buffer
+  - buffer-internal seeking. makes seeking back 1-2 bytes very fast,
+    and makes it possible for sockets where it otherwise wouldn't be
+  - tries to allow switching between reading and writing
+  - support 64-bit and large files
+  - efficient, low-latency buffering
+  - special support for utf8
+  - type-aware functions with byte-order swapping service
+  - position counter for meaningful data offsets with sockets
+
+  theory of operation:
+
+  the buffer is a view of part of a file/stream. you can seek, read, and
+  write around in it as much as you like, as if it were just a string.
+
+  we keep track of the part of the buffer that's invalid (written to).
+  we remember whether the position of the underlying stream is aligned
+  with the end of the buffer (reading mode) or the beginning (writing mode).
+
+  based on this info, we might have to seek back before doing a flush.
+
+  as optimizations, we do no writing if the buffer isn't "dirty", and we
+  do no reading if the data will only be overwritten.
+*/
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
--- a/julia-0.6.2/include/julia/julia.h
+++ b/julia-0.6.2/include/julia/julia.h
--- a/julia-0.6.2/include/julia/julia_threads.h
+++ b/julia-0.6.2/include/julia/julia_threads.h
@ -0,0 +1,637 @@
+// This file is a part of Julia. License is MIT: https://julialang.org/license
+
+// Meant to be included in <julia.h>
+#ifndef JULIA_THREADS_H
+#define JULIA_THREADS_H
+
+// threading ------------------------------------------------------------------
+
+// WARNING: Threading support is incomplete and experimental
+// Nonetheless, we define JL_THREAD and use it to give advanced notice to
+// maintainers of what eventual threading support will change.
+
+// JULIA_ENABLE_THREADING is switched on in Make.inc if JULIA_THREADS is
+// set (in Make.user)
+
+#if defined(__i386__) && defined(__GNUC__) && !defined(__SSE2__)
+#  error Julia can only be built for architectures above Pentium 4. Pass -march=pentium4, or set MARCH=pentium4 and ensure that -march is not passed separately with an older architecture.
+#endif
+#ifdef _COMPILER_MICROSOFT_
+#  include <intrin.h>
+#  include <type_traits>
+#endif
+#if defined(_CPU_X86_64_) || defined(_CPU_X86_)
+#  include <immintrin.h>
+#endif
+#ifndef _OS_WINDOWS_
+#  include <pthread.h>
+#endif
+#include <signal.h>
+
+typedef struct {
+    jl_taggedvalue_t *freelist;   // root of list of free objects
+    jl_taggedvalue_t *newpages;   // root of list of chunks of free objects
+    uint16_t osize;      // size of objects in this pool
+} jl_gc_pool_t;
+
+typedef struct {
+    // variable for tracking weak references
+    arraylist_t weak_refs;
+
+    // variables for tracking malloc'd arrays
+    struct _mallocarray_t *mallocarrays;
+    struct _mallocarray_t *mafreelist;
+
+    // variables for tracking big objects
+    struct _bigval_t *big_objects;
+
+    // variables for tracking "remembered set"
+    arraylist_t rem_bindings;
+    arraylist_t _remset[2]; // contains jl_value_t*
+    // lower bound of the number of pointers inside remembered values
+    int remset_nptr;
+    arraylist_t *remset;
+    arraylist_t *last_remset;
+
+    // variables for allocating objects from pools
+#ifdef _P64
+#  define JL_GC_N_POOLS 41
+#elif defined(_CPU_ARM_) || defined(_CPU_PPC_) || defined(_CPU_X86_)
+#  define JL_GC_N_POOLS 42
+#else
+#  define JL_GC_N_POOLS 43
+#endif
+    jl_gc_pool_t norm_pools[JL_GC_N_POOLS];
+} jl_thread_heap_t;
+
+// Cache of thread local change to global metadata during GC
+// This is sync'd after marking.
+typedef struct {
+    // thread local increment of `perm_scanned_bytes`
+    size_t perm_scanned_bytes;
+    // thread local increment of `scanned_bytes`
+    size_t scanned_bytes;
+    // Number of queued big objects (<= 1024)
+    size_t nbig_obj;
+    // Array of queued big objects to be moved between the young list
+    // and the old list.
+    // A set low bit means that the object should be moved from the old list
+    // to the young list (`mark_reset_age`).
+    // Objects can only be put into this list when the mark bit is flipped to
+    // `1` (atomically). Combining with the sync after marking,
+    // this makes sure that a single objects can only appear once in
+    // the lists (the mark bit cannot be flipped to `0` without sweeping)
+    void *big_obj[1024];
+} jl_gc_mark_cache_t;
+
+// This includes all the thread local states we care about for a thread.
+#define JL_MAX_BT_SIZE 80000
+typedef struct _jl_tls_states_t {
+    struct _jl_gcframe_t *pgcstack;
+    size_t world_age;
+    struct _jl_value_t *exception_in_transit;
+    volatile size_t *safepoint;
+    // Whether it is safe to execute GC at the same time.
+#define JL_GC_STATE_WAITING 1
+    // gc_state = 1 means the thread is doing GC or is waiting for the GC to
+    //              finish.
+#define JL_GC_STATE_SAFE 2
+    // gc_state = 2 means the thread is running unmanaged code that can be
+    //              execute at the same time with the GC.
+    volatile int8_t gc_state;
+    volatile int8_t in_finalizer;
+    int8_t disable_gc;
+    volatile sig_atomic_t defer_signal;
+    struct _jl_module_t *current_module;
+    struct _jl_task_t *volatile current_task;
+    struct _jl_task_t *root_task;
+    void *stackbase;
+    char *stack_lo;
+    char *stack_hi;
+    jl_jmp_buf *volatile jmp_target;
+    jl_jmp_buf base_ctx; // base context of stack
+    jl_jmp_buf *safe_restore;
+    int16_t tid;
+    size_t bt_size;
+    // JL_MAX_BT_SIZE + 1 elements long
+    uintptr_t *bt_data;
+    // Atomically set by the sender, reset by the handler.
+    volatile sig_atomic_t signal_request;
+    // Allow the sigint to be raised asynchronously
+    // this is limited to the few places we do synchronous IO
+    // we can make this more general (similar to defer_signal) if necessary
+    volatile sig_atomic_t io_wait;
+    jl_thread_heap_t heap;
+#ifndef _OS_WINDOWS_
+    // These are only used on unix now
+    pthread_t system_id;
+    void *signal_stack;
+#endif
+    // execution of certain certain impure
+    // statements is prohibited from certain
+    // callbacks (such as generated functions)
+    // as it may make compilation undecidable
+    int in_pure_callback;
+    // Counter to disable finalizer **on the current thread**
+    int finalizers_inhibited;
+    arraylist_t finalizers;
+    jl_gc_mark_cache_t gc_cache;
+} jl_tls_states_t;
+typedef jl_tls_states_t *jl_ptls_t;
+
+// Update codegen version in `ccall.cpp` after changing either `pause` or `wake`
+#ifdef __MIC__
+#  define jl_cpu_pause() _mm_delay_64(100)
+#  define jl_cpu_wake() ((void)0)
+#  define JL_CPU_WAKE_NOOP 1
+#elif defined(_CPU_X86_64_) || defined(_CPU_X86_)  /* !__MIC__ */
+#  define jl_cpu_pause() _mm_pause()
+#  define jl_cpu_wake() ((void)0)
+#  define JL_CPU_WAKE_NOOP 1
+#elif defined(_CPU_AARCH64_) || (defined(_CPU_ARM_) && __ARM_ARCH >= 7)
+#  define jl_cpu_pause() __asm__ volatile ("wfe" ::: "memory")
+#  define jl_cpu_wake() __asm__ volatile ("sev" ::: "memory")
+#  define JL_CPU_WAKE_NOOP 0
+#else
+#  define jl_cpu_pause() ((void)0)
+#  define jl_cpu_wake() ((void)0)
+#  define JL_CPU_WAKE_NOOP 1
+#endif
+
+// Copied from libuv. Add `JL_CONST_FUNC` so that the compiler
+// can optimize this better.
+static inline unsigned long JL_CONST_FUNC jl_thread_self(void)
+{
+#ifdef _OS_WINDOWS_
+    return (unsigned long)GetCurrentThreadId();
+#else
+    return (unsigned long)pthread_self();
+#endif
+}
+
+/**
+ * Thread synchronization primitives:
+ *
+ * These roughly follows the c11/c++11 memory model and the act as memory
+ * barriers at both the compiler level and the hardware level.
+ * The only exception is the GC safepoint and GC state transitions for which
+ * we use only a compiler (signal) barrier and use the signal handler to do the
+ * synchronization in order to lower the mutator overhead as much as possible.
+ *
+ * We use the compiler intrinsics to implement a similar API to the c11/c++11
+ * one instead of using it directly because,
+ *
+ *     1. We support GCC 4.7 and GCC add support for c11 atomics in 4.9.
+ *        Luckily, the __atomic intrinsics were added in GCC 4.7.
+ *     2. (most importantly) we need interoperability between code written
+ *        in different languages.
+ *        The current c++ standard (c++14) does not allow using c11 atomic
+ *        functions or types and there's currently no guarantee that the two
+ *        types are compatible (although most of them probably are).
+ *        We also need to access these atomic variables from the LLVM JIT code
+ *        which is very hard unless the layout of the object is fully
+ *        specified.
+ */
+#if defined(__GNUC__)
+#  define jl_signal_fence() __atomic_signal_fence(__ATOMIC_SEQ_CST)
+#  define jl_atomic_fetch_add_relaxed(obj, arg)         \
+    __atomic_fetch_add(obj, arg, __ATOMIC_RELAXED)
+#  define jl_atomic_fetch_add(obj, arg)                 \
+    __atomic_fetch_add(obj, arg, __ATOMIC_SEQ_CST)
+#  define jl_atomic_fetch_and_relaxed(obj, arg)         \
+    __atomic_fetch_and(obj, arg, __ATOMIC_RELAXED)
+#  define jl_atomic_fetch_and(obj, arg)                 \
+    __atomic_fetch_and(obj, arg, __ATOMIC_SEQ_CST)
+#  define jl_atomic_fetch_or_relaxed(obj, arg)          \
+    __atomic_fetch_or(obj, arg, __ATOMIC_RELAXED)
+#  define jl_atomic_fetch_or(obj, arg)                  \
+    __atomic_fetch_or(obj, arg, __ATOMIC_SEQ_CST)
+// Returns the original value of `obj`
+// Use the legacy __sync builtins for now, this can also be written using
+// the __atomic builtins or c11 atomics with GNU extension or c11 _Generic
+#  define jl_atomic_compare_exchange(obj, expected, desired)    \
+    __sync_val_compare_and_swap(obj, expected, desired)
+#  define jl_atomic_exchange(obj, desired)              \
+    __atomic_exchange_n(obj, desired, __ATOMIC_SEQ_CST)
+#  define jl_atomic_exchange_relaxed(obj, desired)      \
+    __atomic_exchange_n(obj, desired, __ATOMIC_RELAXED)
+// TODO: Maybe add jl_atomic_compare_exchange_weak for spin lock
+#  define jl_atomic_store(obj, val)                     \
+    __atomic_store_n(obj, val, __ATOMIC_SEQ_CST)
+#  if defined(__clang__) || defined(__ICC) || defined(__INTEL_COMPILER) || \
+    !(defined(_CPU_X86_) || defined(_CPU_X86_64_))
+// ICC and Clang doesn't have this bug...
+#    define jl_atomic_store_release(obj, val)           \
+    __atomic_store_n(obj, val, __ATOMIC_RELEASE)
+#  else
+// Workaround a GCC bug when using store with release order by using the
+// stronger version instead.
+// https://gcc.gnu.org/bugzilla/show_bug.cgi?id=67458
+#    define jl_atomic_store_release(obj, val) do {      \
+        jl_signal_fence();                              \
+        __atomic_store_n(obj, val, __ATOMIC_RELEASE);   \
+    } while (0)
+#  endif
+#  define jl_atomic_load(obj)                   \
+    __atomic_load_n(obj, __ATOMIC_SEQ_CST)
+#  define jl_atomic_load_acquire(obj)           \
+    __atomic_load_n(obj, __ATOMIC_ACQUIRE)
+#elif defined(_COMPILER_MICROSOFT_)
+#  define jl_signal_fence() _ReadWriteBarrier()
+
+// add
+template<typename T, typename T2>
+static inline typename std::enable_if<sizeof(T) == 1, T>::type
+jl_atomic_fetch_add(T *obj, T2 arg)
+{
+    return (T)_InterlockedExchangeAdd8((volatile char*)obj, (char)arg);
+}
+template<typename T, typename T2>
+static inline typename std::enable_if<sizeof(T) == 2, T>::type
+jl_atomic_fetch_add(T *obj, T2 arg)
+{
+    return (T)_InterlockedExchangeAdd16((volatile short*)obj, (short)arg);
+}
+template<typename T, typename T2>
+static inline typename std::enable_if<sizeof(T) == 4, T>::type
+jl_atomic_fetch_add(T *obj, T2 arg)
+{
+    return (T)_InterlockedExchangeAdd((volatile LONG*)obj, (LONG)arg);
+}
+template<typename T, typename T2>
+static inline typename std::enable_if<sizeof(T) == 8, T>::type
+jl_atomic_fetch_add(T *obj, T2 arg)
+{
+    return (T)_InterlockedExchangeAdd64((volatile __int64*)obj, (__int64)arg);
+}
+#define jl_atomic_fetch_add_relaxed(obj, arg) jl_atomic_fetch_add(obj, arg)
+
+// and
+template<typename T, typename T2>
+static inline typename std::enable_if<sizeof(T) == 1, T>::type
+jl_atomic_fetch_and(T *obj, T2 arg)
+{
+    return (T)_InterlockedAnd8((volatile char*)obj, (char)arg);
+}
+template<typename T, typename T2>
+static inline typename std::enable_if<sizeof(T) == 2, T>::type
+jl_atomic_fetch_and(T *obj, T2 arg)
+{
+    return (T)_InterlockedAnd16((volatile short*)obj, (short)arg);
+}
+template<typename T, typename T2>
+static inline typename std::enable_if<sizeof(T) == 4, T>::type
+jl_atomic_fetch_and(T *obj, T2 arg)
+{
+    return (T)_InterlockedAnd((volatile LONG*)obj, (LONG)arg);
+}
+template<typename T, typename T2>
+static inline typename std::enable_if<sizeof(T) == 8, T>::type
+jl_atomic_fetch_and(T *obj, T2 arg)
+{
+    return (T)_InterlockedAnd64((volatile __int64*)obj, (__int64)arg);
+}
+#define jl_atomic_fetch_and_relaxed(obj, arg) jl_atomic_fetch_and(obj, arg)
+
+// or
+template<typename T, typename T2>
+static inline typename std::enable_if<sizeof(T) == 1, T>::type
+jl_atomic_fetch_or(T *obj, T2 arg)
+{
+    return (T)_InterlockedOr8((volatile char*)obj, (char)arg);
+}
+template<typename T, typename T2>
+static inline typename std::enable_if<sizeof(T) == 2, T>::type
+jl_atomic_fetch_or(T *obj, T2 arg)
+{
+    return (T)_InterlockedOr16((volatile short*)obj, (short)arg);
+}
+template<typename T, typename T2>
+static inline typename std::enable_if<sizeof(T) == 4, T>::type
+jl_atomic_fetch_or(T *obj, T2 arg)
+{
+    return (T)_InterlockedOr((volatile LONG*)obj, (LONG)arg);
+}
+template<typename T, typename T2>
+static inline typename std::enable_if<sizeof(T) == 8, T>::type
+jl_atomic_fetch_or(T *obj, T2 arg)
+{
+    return (T)_InterlockedOr64((volatile __int64*)obj, (__int64)arg);
+}
+#define jl_atomic_fetch_or_relaxed(obj, arg) jl_atomic_fetch_or(obj, arg)
+
+// Returns the original value of `obj`
+template<typename T, typename T2, typename T3>
+static inline typename std::enable_if<sizeof(T) == 1, T>::type
+jl_atomic_compare_exchange(volatile T *obj, T2 expected, T3 desired)
+{
+    return (T)_InterlockedCompareExchange8((volatile char*)obj,
+                                           (char)desired, (char)expected);
+}
+template<typename T, typename T2, typename T3>
+static inline typename std::enable_if<sizeof(T) == 2, T>::type
+jl_atomic_compare_exchange(volatile T *obj, T2 expected, T3 desired)
+{
+    return (T)_InterlockedCompareExchange16((volatile short*)obj,
+                                            (short)desired, (short)expected);
+}
+template<typename T, typename T2, typename T3>
+static inline typename std::enable_if<sizeof(T) == 4, T>::type
+jl_atomic_compare_exchange(volatile T *obj, T2 expected, T3 desired)
+{
+    return (T)_InterlockedCompareExchange((volatile LONG*)obj,
+                                          (LONG)desired, (LONG)expected);
+}
+template<typename T, typename T2, typename T3>
+static inline typename std::enable_if<sizeof(T) == 8, T>::type
+jl_atomic_compare_exchange(volatile T *obj, T2 expected, T3 desired)
+{
+    return (T)_InterlockedCompareExchange64((volatile __int64*)obj,
+                                            (__int64)desired, (__int64)expected);
+}
+// atomic exchange
+template<typename T, typename T2>
+static inline typename std::enable_if<sizeof(T) == 1, T>::type
+jl_atomic_exchange(volatile T *obj, T2 val)
+{
+    return _InterlockedExchange8((volatile char*)obj, (char)val);
+}
+template<typename T, typename T2>
+static inline typename std::enable_if<sizeof(T) == 2, T>::type
+jl_atomic_exchange(volatile T *obj, T2 val)
+{
+    return _InterlockedExchange16((volatile short*)obj, (short)val);
+}
+template<typename T, typename T2>
+static inline typename std::enable_if<sizeof(T) == 4, T>::type
+jl_atomic_exchange(volatile T *obj, T2 val)
+{
+    return _InterlockedExchange((volatile LONG*)obj, (LONG)val);
+}
+template<typename T, typename T2>
+static inline typename std::enable_if<sizeof(T) == 8, T>::type
+jl_atomic_exchange(volatile T *obj, T2 val)
+{
+    return _InterlockedExchange64((volatile __int64*)obj, (__int64)val);
+}
+#define jl_atomic_exchange_relaxed(obj, val) jl_atomic_exchange(obj, val)
+// atomic stores
+template<typename T, typename T2>
+static inline typename std::enable_if<sizeof(T) == 1>::type
+jl_atomic_store(volatile T *obj, T2 val)
+{
+    _InterlockedExchange8((volatile char*)obj, (char)val);
+}
+template<typename T, typename T2>
+static inline typename std::enable_if<sizeof(T) == 2>::type
+jl_atomic_store(volatile T *obj, T2 val)
+{
+    _InterlockedExchange16((volatile short*)obj, (short)val);
+}
+template<typename T, typename T2>
+static inline typename std::enable_if<sizeof(T) == 4>::type
+jl_atomic_store(volatile T *obj, T2 val)
+{
+    _InterlockedExchange((volatile LONG*)obj, (LONG)val);
+}
+template<typename T, typename T2>
+static inline typename std::enable_if<sizeof(T) == 8>::type
+jl_atomic_store(volatile T *obj, T2 val)
+{
+    _InterlockedExchange64((volatile __int64*)obj, (__int64)val);
+}
+template<typename T, typename T2>
+static inline void jl_atomic_store_release(volatile T *obj, T2 val)
+{
+    jl_signal_fence();
+    *obj = (T)val;
+}
+// atomic loads
+template<typename T>
+static inline T jl_atomic_load(volatile T *obj)
+{
+    // Trick to generate cheaper instructions compare to `_InterlockedOr`
+    // Note that we don't care whether the exchange succeeded or not...
+    return jl_atomic_compare_exchange(obj, T(0), T(0));
+}
+template<typename T>
+static inline T jl_atomic_load_acquire(volatile T *obj)
+{
+    T val = *obj;
+    jl_signal_fence();
+    return val;
+}
+#else
+#  error "No atomic operations supported."
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+JL_DLLEXPORT int16_t jl_threadid(void);
+JL_DLLEXPORT void *jl_threadgroup(void);
+JL_DLLEXPORT void jl_threading_profile(void);
+JL_DLLEXPORT void (jl_cpu_pause)(void);
+JL_DLLEXPORT void (jl_cpu_wake)(void);
+
+// Accessing the tls variables, gc safepoint and gc states
+JL_DLLEXPORT JL_CONST_FUNC jl_ptls_t (jl_get_ptls_states)(void);
+// This triggers a SegFault when we are in GC
+// Assign it to a variable to make sure the compiler emit the load
+// and to avoid Clang warning for -Wunused-volatile-lvalue
+#define jl_gc_safepoint_(ptls) do {                     \
+        jl_signal_fence();                              \
+        size_t safepoint_load = *ptls->safepoint;       \
+        jl_signal_fence();                              \
+        (void)safepoint_load;                           \
+    } while (0)
+#define jl_sigint_safepoint(ptls) do {                  \
+        jl_signal_fence();                              \
+        size_t safepoint_load = ptls->safepoint[-1];    \
+        jl_signal_fence();                              \
+        (void)safepoint_load;                           \
+    } while (0)
+#ifndef JULIA_ENABLE_THREADING
+extern JL_DLLEXPORT jl_tls_states_t jl_tls_states;
+#define jl_get_ptls_states() (&jl_tls_states)
+#define jl_gc_state(ptls) ((int8_t)0)
+STATIC_INLINE int8_t jl_gc_state_set(jl_ptls_t ptls, int8_t state,
+                                     int8_t old_state)
+{
+    (void)ptls;
+    (void)state;
+    return old_state;
+}
+#else // ifndef JULIA_ENABLE_THREADING
+typedef jl_ptls_t (*jl_get_ptls_states_func)(void);
+#if !defined(_OS_DARWIN_) && !defined(_OS_WINDOWS_)
+JL_DLLEXPORT void jl_set_ptls_states_getter(jl_get_ptls_states_func f);
+#endif
+// Make sure jl_gc_state() is always a rvalue
+#define jl_gc_state(ptls) ((int8_t)ptls->gc_state)
+STATIC_INLINE int8_t jl_gc_state_set(jl_ptls_t ptls, int8_t state,
+                                     int8_t old_state)
+{
+    ptls->gc_state = state;
+    // A safe point is required if we transition from GC-safe region to
+    // non GC-safe region.
+    if (old_state && !state)
+        jl_gc_safepoint_(ptls);
+    return old_state;
+}
+#endif // ifndef JULIA_ENABLE_THREADING
+STATIC_INLINE int8_t jl_gc_state_save_and_set(jl_ptls_t ptls,
+                                              int8_t state)
+{
+    return jl_gc_state_set(ptls, state, jl_gc_state(ptls));
+}
+#define jl_gc_unsafe_enter(ptls) jl_gc_state_save_and_set(ptls, 0)
+#define jl_gc_unsafe_leave(ptls, state) ((void)jl_gc_state_set(ptls, (state), 0))
+#define jl_gc_safe_enter(ptls) jl_gc_state_save_and_set(ptls, JL_GC_STATE_SAFE)
+#define jl_gc_safe_leave(ptls, state) ((void)jl_gc_state_set(ptls, (state), JL_GC_STATE_SAFE))
+JL_DLLEXPORT void (jl_gc_safepoint)(void);
+
+#define JL_SIGATOMIC_BEGIN() do {               \
+        jl_get_ptls_states()->defer_signal++;   \
+        jl_signal_fence();                      \
+    } while (0)
+#define JL_SIGATOMIC_END() do {                                 \
+        jl_signal_fence();                                      \
+        if (--jl_get_ptls_states()->defer_signal == 0) {        \
+            jl_sigint_safepoint(jl_get_ptls_states());          \
+        }                                                       \
+    } while (0)
+
+// Recursive spin lock
+typedef struct {
+    volatile unsigned long owner;
+    uint32_t count;
+} jl_mutex_t;
+
+JL_DLLEXPORT void jl_gc_enable_finalizers(jl_ptls_t ptls, int on);
+static inline void jl_lock_frame_push(jl_mutex_t *lock);
+static inline void jl_lock_frame_pop(void);
+
+// JL_LOCK and jl_mutex_lock are GC safe points while JL_LOCK_NOGC
+// and jl_mutex_lock_nogc are not.
+// Always use JL_LOCK unless no one holding the lock can trigger a GC or GC
+// safepoint. JL_LOCK_NOGC should only be needed for GC internal locks.
+// The JL_LOCK* and JL_UNLOCK* macros are no-op for non-threading build
+// while the jl_mutex_* functions are always locking and unlocking the locks.
+
+static inline void jl_mutex_wait(jl_mutex_t *lock, int safepoint)
+{
+    unsigned long self = jl_thread_self();
+    unsigned long owner = jl_atomic_load_acquire(&lock->owner);
+    if (owner == self) {
+        lock->count++;
+        return;
+    }
+    while (1) {
+        if (owner == 0 &&
+            jl_atomic_compare_exchange(&lock->owner, 0, self) == 0) {
+            lock->count = 1;
+            return;
+        }
+        if (safepoint) {
+            jl_ptls_t ptls = jl_get_ptls_states();
+            jl_gc_safepoint_(ptls);
+        }
+        jl_cpu_pause();
+        owner = lock->owner;
+    }
+}
+
+static inline void jl_mutex_lock_nogc(jl_mutex_t *lock)
+{
+    jl_mutex_wait(lock, 0);
+}
+
+static inline void jl_mutex_lock(jl_mutex_t *lock)
+{
+    jl_ptls_t ptls = jl_get_ptls_states();
+    JL_SIGATOMIC_BEGIN();
+    jl_mutex_wait(lock, 1);
+    jl_lock_frame_push(lock);
+    jl_gc_enable_finalizers(ptls, 0);
+}
+
+/* Call this function for code that could be called from either a managed
+   or an unmanaged thread */
+static inline void jl_mutex_lock_maybe_nogc(jl_mutex_t *lock)
+{
+    jl_ptls_t ptls = jl_get_ptls_states();
+    if (ptls->safepoint) {
+        jl_mutex_lock(lock);
+    } else {
+        jl_mutex_lock_nogc(lock);
+    }
+}
+
+static inline void jl_mutex_unlock_nogc(jl_mutex_t *lock)
+{
+    assert(lock->owner == jl_thread_self() &&
+           "Unlocking a lock in a different thread.");
+    if (--lock->count == 0) {
+        jl_atomic_store_release(&lock->owner, 0);
+        jl_cpu_wake();
+    }
+}
+
+static inline void jl_mutex_unlock(jl_mutex_t *lock)
+{
+    jl_ptls_t ptls = jl_get_ptls_states();
+    jl_mutex_unlock_nogc(lock);
+    jl_gc_enable_finalizers(ptls, 1);
+    jl_lock_frame_pop();
+    JL_SIGATOMIC_END();
+}
+
+static inline void jl_mutex_unlock_maybe_nogc(jl_mutex_t *lock) {
+    jl_ptls_t ptls = jl_get_ptls_states();
+    if (ptls->safepoint) {
+        jl_mutex_unlock(lock);
+    } else {
+        jl_mutex_unlock_nogc(lock);
+    }
+}
+
+static inline void jl_mutex_init(jl_mutex_t *lock)
+{
+    lock->owner = 0;
+    lock->count = 0;
+}
+
+// Locks
+#ifdef JULIA_ENABLE_THREADING
+#define JL_MUTEX_INIT(m) jl_mutex_init(m)
+#define JL_LOCK(m) jl_mutex_lock(m)
+#define JL_UNLOCK(m) jl_mutex_unlock(m)
+#define JL_LOCK_NOGC(m) jl_mutex_lock_nogc(m)
+#define JL_UNLOCK_NOGC(m) jl_mutex_unlock_nogc(m)
+#else // JULIA_ENABLE_THREADING
+static inline void jl_mutex_check_type(jl_mutex_t *m)
+{
+    (void)m;
+}
+#define JL_MUTEX_INIT(m) jl_mutex_check_type(m)
+#define JL_LOCK(m) do {                                   \
+        JL_SIGATOMIC_BEGIN();                             \
+        jl_gc_enable_finalizers(jl_get_ptls_states(), 0); \
+        jl_mutex_check_type(m);                           \
+    } while (0)
+#define JL_UNLOCK(m) do {                                       \
+        jl_gc_enable_finalizers(jl_get_ptls_states(), 1);       \
+        jl_mutex_check_type(m);                                 \
+        JL_SIGATOMIC_END();                                     \
+    } while (0)
+#define JL_LOCK_NOGC(m) jl_mutex_check_type(m)
+#define JL_UNLOCK_NOGC(m) jl_mutex_check_type(m)
+#endif // JULIA_ENABLE_THREADING
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
--- a/julia-0.6.2/include/julia/julia_version.h
+++ b/julia-0.6.2/include/julia/julia_version.h
@ -0,0 +1,9 @@
+// This is an autogenerated header file
+#ifndef JULIA_VERSION_H
+#define JULIA_VERSION_H
+#define JULIA_VERSION_STRING "0.6.2"
+#define JULIA_VERSION_MAJOR 0
+#define JULIA_VERSION_MINOR 6
+#define JULIA_VERSION_PATCH 2
+#define JULIA_VERSION_IS_RELEASE 1
+#endif
--- a/julia-0.6.2/include/julia/libsupport.h
+++ b/julia-0.6.2/include/julia/libsupport.h
@ -0,0 +1,33 @@
+// This file is a part of Julia. License is MIT: https://julialang.org/license
+
+#ifndef LIBSUPPORT_H
+#define LIBSUPPORT_H
+
+#include "platform.h"
+
+#include <stdlib.h>
+#include <stdarg.h>
+#include <assert.h>
+#include "dtypes.h"
+#include "utils.h"
+#include "utf8.h"
+#include "ios.h"
+#include "timefuncs.h"
+#include "hashing.h"
+#include "ptrhash.h"
+#include "bitvector.h"
+#include "dirpath.h"
+#include "strtod.h"
+#include "crc32c.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+JL_DLLEXPORT void libsupport_init(void);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
--- a/julia-0.6.2/include/julia/platform.h
+++ b/julia-0.6.2/include/julia/platform.h
@ -0,0 +1,113 @@
+// This file is a part of Julia. License is MIT: https://julialang.org/license
+
+#ifndef PLATFORM_H
+#define PLATFORM_H
+
+/*
+ * This file provides convenient macros to be used to identify the platform
+ * based of compiler-specific pre-defined macros. It is based on the
+ * information that can be found at the following address:
+ *
+ *     http://sourceforge.net/p/predef/wiki/Home/
+ *
+ * Possible values include:
+ *      Compiler:
+ *          _COMPILER_CLANG_
+ *          _COMPILER_GCC_
+ *          _COMPILER_INTEL_
+ *          _COMPILER_MICROSOFT_
+ *          _COMPILER_MINGW_
+ *      OS:
+ *          _OS_FREEBSD_
+ *          _OS_LINUX_
+ *          _OS_WINDOWS_
+ *          _OS_DARWIN_
+ *
+ *      CPU/Architecture:
+ *          _CPU_X86_
+ *          _CPU_X86_64_
+ *          _CPU_ARM_
+ */
+
+/*******************************************************************************
+*                               Compiler                                       *
+*******************************************************************************/
+
+/*
+ * Notes:
+ *
+ *  1. Checking for Intel's compiler should be done before checking for
+ * Microsoft's. On Windows Intel's compiler also defines _MSC_VER as the
+ * acknoledgement of the fact that it is integrated with Visual Studio.
+ *
+ *  2. Checking for MinGW should be done before checking for GCC as MinGW
+ * pretends to be GCC.
+ */
+#if defined(__clang__)
+#define _COMPILER_CLANG_
+// Clang can also be used as a MinGW compiler
+#if defined(__MINGW32__)
+#define _COMPILER_MINGW_
+#endif
+#elif defined(__INTEL_COMPILER) || defined(__ICC)
+#define _COMPILER_INTEL_
+#elif defined(__MINGW32__)
+#define _COMPILER_MINGW_
+#elif defined(_MSC_VER)
+#define _COMPILER_MICROSOFT_
+#elif defined(__GNUC__)
+#define _COMPILER_GCC_
+#endif
+
+/*******************************************************************************
+*                               OS                                             *
+*******************************************************************************/
+
+#if defined(__FreeBSD__)
+#define _OS_FREEBSD_
+#elif defined(__linux__)
+#define _OS_LINUX_
+#elif defined(_WIN32) || defined(_WIN64)
+#define _OS_WINDOWS_
+#elif defined(__APPLE__) && defined(__MACH__)
+#define _OS_DARWIN_
+#endif
+
+/*******************************************************************************
+*                               Architecture                                   *
+*******************************************************************************/
+
+#if defined(__amd64__) || defined(__amd64) || defined(__x86_64__) || defined(__x86_64) || defined(_M_X64) || defined(_M_AMD64)
+#define _CPU_X86_64_
+#elif defined(i386) || defined(__i386) || defined(__i386__) || defined(_M_IX86) || defined(_X86_)
+#define _CPU_X86_
+#elif defined(__aarch64__)
+#define _CPU_AARCH64_
+#elif defined(__arm__) || defined(_M_ARM)
+#define _CPU_ARM_
+#elif defined(__PPC64__)
+#define _CPU_PPC64_
+#elif defined(_ARCH_PPC)
+#define _CPU_PPC_
+#endif
+
+#if defined(_CPU_X86_64_)
+#  define _P64
+#elif defined(_CPU_X86_)
+#  define _P32
+#elif defined(_OS_WINDOWS_)
+/* Not sure how to determine pointer size on Windows running ARM. */
+#  if _WIN64
+#    define _P64
+#  else
+#    define _P32
+#  endif
+#elif __SIZEOF_POINTER__ == 8
+#    define _P64
+#elif __SIZEOF_POINTER__ == 4
+#    define _P32
+#else
+#  error pointer size not known for your platform / compiler
+#endif
+
+#endif /* !PLATFORM_H */
--- a/julia-0.6.2/include/julia/ptrhash.h
+++ b/julia-0.6.2/include/julia/ptrhash.h
@ -0,0 +1,18 @@
+// This file is a part of Julia. License is MIT: https://julialang.org/license
+
+#ifndef PTRHASH_H
+#define PTRHASH_H
+
+#include "htable.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+HTPROT(ptrhash)
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
--- a/julia-0.6.2/include/julia/strtod.h
+++ b/julia-0.6.2/include/julia/strtod.h
@ -0,0 +1,17 @@
+// This file is a part of Julia. License is MIT: https://julialang.org/license
+
+#ifndef STRTOD_H
+#define STRTOD_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+JL_DLLEXPORT double jl_strtod_c(const char *nptr, char **endptr);
+JL_DLLEXPORT float jl_strtof_c(const char *nptr, char **endptr);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
--- a/julia-0.6.2/include/julia/timefuncs.h
+++ b/julia-0.6.2/include/julia/timefuncs.h
@ -0,0 +1,23 @@
+// This file is a part of Julia. License is MIT: https://julialang.org/license
+
+#ifndef TIMEFUNCS_H
+#define TIMEFUNCS_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+struct jl_timeval {
+    int64_t sec;    /* seconds */
+    int64_t usec;   /* microseconds */
+};
+
+JL_DLLEXPORT int jl_gettimeofday(struct jl_timeval *jtv);
+JL_DLLEXPORT double jl_clock_now(void);
+void sleep_ms(int ms);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
--- a/julia-0.6.2/include/julia/tzfile.h
+++ b/julia-0.6.2/include/julia/tzfile.h
@ -0,0 +1,170 @@
+/*	$NetBSD: tzfile.h,v 1.8 2015/07/11 16:40:53 christos Exp $	*/
+
+#ifndef _TZFILE_H_
+#define _TZFILE_H_
+
+/*
+** This file is in the public domain, so clarified as of
+** 1996-06-05 by Arthur David Olson.
+*/
+
+/*
+** This header is for use ONLY with the time conversion code.
+** There is no guarantee that it will remain unchanged,
+** or that it will remain at all.
+** Do NOT copy it to any system include directory.
+** Thank you!
+*/
+
+/*
+** Information about time zone files.
+*/
+
+#ifndef TZDIR		/* Time zone object file directory */
+#define TZDIR		"/usr/share/zoneinfo"
+#endif /* !defined TZDIR */
+
+#ifndef TZDEFAULT
+#define TZDEFAULT	"/etc/localtime"
+#endif /* !defined TZDEFAULT */
+
+#ifndef TZDEFRULES
+#define TZDEFRULES	"posixrules"
+#endif /* !defined TZDEFRULES */
+
+/*
+** Each file begins with. . .
+*/
+
+#define	TZ_MAGIC	"TZif"
+
+struct tzhead {
+	char	tzh_magic[4];		/* TZ_MAGIC */
+	char	tzh_version[1];		/* '\0' or '2' or '3' as of 2013 */
+	char	tzh_reserved[15];	/* reserved; must be zero */
+	char	tzh_ttisgmtcnt[4];	/* coded number of trans. time flags */
+	char	tzh_ttisstdcnt[4];	/* coded number of trans. time flags */
+	char	tzh_leapcnt[4];		/* coded number of leap seconds */
+	char	tzh_timecnt[4];		/* coded number of transition times */
+	char	tzh_typecnt[4];		/* coded number of local time types */
+	char	tzh_charcnt[4];		/* coded number of abbr. chars */
+};
+
+/*
+** . . .followed by. . .
+**
+**	tzh_timecnt (char [4])s		coded transition times a la time(2)
+**	tzh_timecnt (unsigned char)s	types of local time starting at above
+**	tzh_typecnt repetitions of
+**		one (char [4])		coded UT offset in seconds
+**		one (unsigned char)	used to set tm_isdst
+**		one (unsigned char)	that's an abbreviation list index
+**	tzh_charcnt (char)s		'\0'-terminated zone abbreviations
+**	tzh_leapcnt repetitions of
+**		one (char [4])		coded leap second transition times
+**		one (char [4])		total correction after above
+**	tzh_ttisstdcnt (char)s		indexed by type; if 1, transition
+**					time is standard time, if 0,
+**					transition time is wall clock time
+**					if absent, transition times are
+**					assumed to be wall clock time
+**	tzh_ttisgmtcnt (char)s		indexed by type; if 1, transition
+**					time is UT, if 0,
+**					transition time is local time
+**					if absent, transition times are
+**					assumed to be local time
+*/
+
+/*
+** If tzh_version is '2' or greater, the above is followed by a second instance
+** of tzhead and a second instance of the data in which each coded transition
+** time uses 8 rather than 4 chars,
+** then a POSIX-TZ-environment-variable-style string for use in handling
+** instants after the last transition time stored in the file
+** (with nothing between the newlines if there is no POSIX representation for
+** such instants).
+**
+** If tz_version is '3' or greater, the above is extended as follows.
+** First, the POSIX TZ string's hour offset may range from -167
+** through 167 as compared to the POSIX-required 0 through 24.
+** Second, its DST start time may be January 1 at 00:00 and its stop
+** time December 31 at 24:00 plus the difference between DST and
+** standard time, indicating DST all year.
+*/
+
+/*
+** In the current implementation, "tzset()" refuses to deal with files that
+** exceed any of the limits below.
+*/
+
+#ifndef TZ_MAX_TIMES
+#define TZ_MAX_TIMES	2000
+#endif /* !defined TZ_MAX_TIMES */
+
+#ifndef TZ_MAX_TYPES
+/* This must be at least 17 for Europe/Samara and Europe/Vilnius.  */
+#define TZ_MAX_TYPES	256 /* Limited by what (unsigned char)'s can hold */
+#endif /* !defined TZ_MAX_TYPES */
+
+#ifndef TZ_MAX_CHARS
+#define TZ_MAX_CHARS	50	/* Maximum number of abbreviation characters */
+				/* (limited by what unsigned chars can hold) */
+#endif /* !defined TZ_MAX_CHARS */
+
+#ifndef TZ_MAX_LEAPS
+#define TZ_MAX_LEAPS	50	/* Maximum number of leap second corrections */
+#endif /* !defined TZ_MAX_LEAPS */
+
+#define SECSPERMIN	60
+#define MINSPERHOUR	60
+#define HOURSPERDAY	24
+#define DAYSPERWEEK	7
+#define DAYSPERNYEAR	365
+#define DAYSPERLYEAR	366
+#define SECSPERHOUR	(SECSPERMIN * MINSPERHOUR)
+#define SECSPERDAY	((int_fast32_t) SECSPERHOUR * HOURSPERDAY)
+#define MONSPERYEAR	12
+
+#define TM_SUNDAY	0
+#define TM_MONDAY	1
+#define TM_TUESDAY	2
+#define TM_WEDNESDAY	3
+#define TM_THURSDAY	4
+#define TM_FRIDAY	5
+#define TM_SATURDAY	6
+
+#define TM_JANUARY	0
+#define TM_FEBRUARY	1
+#define TM_MARCH	2
+#define TM_APRIL	3
+#define TM_MAY		4
+#define TM_JUNE		5
+#define TM_JULY		6
+#define TM_AUGUST	7
+#define TM_SEPTEMBER	8
+#define TM_OCTOBER	9
+#define TM_NOVEMBER	10
+#define TM_DECEMBER	11
+
+#define TM_YEAR_BASE	1900
+
+#define EPOCH_YEAR	1970
+#define EPOCH_WDAY	TM_THURSDAY
+
+#define isleap(y) (((y) % 4) == 0 && (((y) % 100) != 0 || ((y) % 400) == 0))
+
+/*
+** Since everything in isleap is modulo 400 (or a factor of 400), we know that
+**	isleap(y) == isleap(y % 400)
+** and so
+**	isleap(a + b) == isleap((a + b) % 400)
+** or
+**	isleap(a + b) == isleap(a % 400 + b % 400)
+** This is true even if % means modulo rather than Fortran remainder
+** (which is allowed by C89 but not C99).
+** We use this to avoid addition overflow problems.
+*/
+
+#define isleap_sum(a, b)	isleap((a) % 400 + (b) % 400)
+
+#endif /* !defined _TZFILE_H_ */
--- a/julia-0.6.2/include/julia/utf8.h
+++ b/julia-0.6.2/include/julia/utf8.h
@ -0,0 +1,104 @@
+// This file is a part of Julia. License is MIT: https://julialang.org/license
+
+#ifndef UTF8_H
+#define UTF8_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* is c the start of a utf8 sequence? */
+#define isutf(c) (((c)&0xC0)!=0x80)
+
+#define UEOF ((uint32_t)-1)
+
+/* convert UTF-8 data to wide character */
+size_t u8_toucs(uint32_t *dest, size_t sz, const char *src, size_t srcsz);
+
+/* the opposite conversion */
+size_t u8_toutf8(char *dest, size_t sz, const uint32_t *src, size_t srcsz);
+
+/* single character to UTF-8, returns # bytes written */
+size_t u8_wc_toutf8(char *dest, uint32_t ch);
+
+/* character number to byte offset */
+JL_DLLEXPORT size_t u8_offset(const char *str, size_t charnum);
+
+/* byte offset to character number */
+JL_DLLEXPORT size_t u8_charnum(const char *str, size_t offset);
+
+/* return next character, updating an index variable */
+uint32_t u8_nextchar(const char *s, size_t *i);
+
+/* next character without NUL character terminator */
+uint32_t u8_nextmemchar(const char *s, size_t *i);
+
+/* move to next character */
+void u8_inc(const char *s, size_t *i);
+
+/* move to previous character */
+void u8_dec(const char *s, size_t *i);
+
+/* returns length of next utf-8 sequence */
+size_t u8_seqlen(const char *s);
+
+/* returns the # of bytes needed to encode a certain character */
+size_t u8_charlen(uint32_t ch);
+
+char read_escape_control_char(char c);
+
+/* assuming src points to the character after a backslash, read an
+   escape sequence, storing the result in dest and returning the number of
+   input characters processed */
+size_t u8_read_escape_sequence(const char *src, size_t ssz, uint32_t *dest);
+
+/* given a wide character, convert it to an ASCII escape sequence stored in
+   buf, where buf is "sz" bytes. returns the number of characters output.
+   sz must be at least 3. */
+int u8_escape_wchar(char *buf, size_t sz, uint32_t ch);
+
+/* convert UTF-8 "src" to escape sequences.
+
+   sz is buf size in bytes. must be at least 12.
+
+   if escape_quotes is nonzero, quote characters will be escaped.
+
+   if ascii is nonzero, the output is 7-bit ASCII, no UTF-8 survives.
+
+   starts at src[*pi], updates *pi to point to the first unprocessed
+   byte of the input.
+
+   end is one more than the last allowable value of *pi.
+
+   returns number of bytes placed in buf, including a NUL terminator.
+*/
+size_t u8_escape(char *buf, size_t sz, const char *src, size_t *pi, size_t end,
+                 int escape_quotes, int ascii);
+
+/* utility predicates used by the above */
+int octal_digit(char c);
+int hex_digit(char c);
+
+/* same as the above, but searches a buffer of a given size instead of
+   a NUL-terminated string. */
+char *u8_memchr(const char *s, uint32_t ch, size_t sz, size_t *charn);
+
+char *u8_memrchr(const char *s, uint32_t ch, size_t sz);
+
+/* number of columns occupied by a string */
+JL_DLLEXPORT size_t u8_strwidth(const char *s);
+
+/* printf where the format string and arguments may be in UTF-8.
+   you can avoid this function and just use ordinary printf() if the current
+   locale is UTF-8. */
+size_t u8_vprintf(const char *fmt, va_list ap);
+size_t u8_printf(const char *fmt, ...);
+
+/* determine whether a sequence of bytes is valid UTF-8. length is in bytes */
+JL_DLLEXPORT int u8_isvalid(const char *str, size_t length);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
--- a/julia-0.6.2/include/julia/utils.h
+++ b/julia-0.6.2/include/julia/utils.h
@ -0,0 +1,63 @@
+// This file is a part of Julia. License is MIT: https://julialang.org/license
+
+#ifndef UTILS_H
+#define UTILS_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+JL_DLLEXPORT char *uint2str(char *dest, size_t len, uint64_t num, uint32_t base);
+int str2int(char *str, size_t len, int64_t *res, uint32_t base);
+int isdigit_base(char c, int base);
+
+double conv_to_double(void *data, numerictype_t tag);
+int64_t conv_to_int64(void *data, numerictype_t tag);
+uint64_t conv_to_uint64(void *data, numerictype_t tag);
+int32_t conv_to_int32(void *data, numerictype_t tag);
+uint32_t conv_to_uint32(void *data, numerictype_t tag);
+#ifdef _P64
+#define conv_to_ptrdiff conv_to_int64
+#define conv_to_size conv_to_uint64
+#else
+#define conv_to_ptrdiff conv_to_int32
+#define conv_to_size conv_to_uint32
+#endif
+int cmp_same_lt(void *a, void *b, numerictype_t tag);
+int cmp_same_eq(void *a, void *b, numerictype_t tag);
+int cmp_lt(void *a, numerictype_t atag, void *b, numerictype_t btag);
+int cmp_eq(void *a, numerictype_t atag, void *b, numerictype_t btag,
+           int equalnans);
+
+#if defined(__clang__) || (defined(__GNUC__) && (__GNUC__ > 4 || __GNUC_MINOR__ >= 8))
+#define bswap_16(x) __builtin_bswap16(x)
+#define bswap_32(x) __builtin_bswap32(x)
+#define bswap_64(x) __builtin_bswap64(x)
+#elif defined(_MSC_VER)
+#define bswap_16(x) _byteswap_ushort(x)
+#define bswap_32(x) _byteswap_ulong(x)
+#define bswap_64(x) _byteswap_uint64(x)
+#elif defined(__INTEL_COMPILER)
+#define bswap_16(x) _bswap16(x)
+#define bswap_32(x) _bswap(x)
+#define bswap_64(x) _bswap64(x)
+#else
+#define bswap_16(x) (((x) & 0x00ff) << 8 | ((x) & 0xff00) >> 8)
+#define bswap_32(x) \
+     ((((x) & 0xff000000) >> 24) | (((x) & 0x00ff0000) >>  8) | \
+      (((x) & 0x0000ff00) <<  8) | (((x) & 0x000000ff) << 24))
+STATIC_INLINE uint64_t ByteSwap64(uint64_t x)
+{
+    uint32_t high = (uint32_t) (x >> 32);
+    uint32_t low  = (uint32_t)  x;
+    return  ((uint64_t) bswap_32 (high)) |
+           (((uint64_t) bswap_32 (low)) << 32);
+}
+#define bswap_64(x) ByteSwap64(x)
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
--- a/julia-0.6.2/include/julia/uv-errno.h
+++ b/julia-0.6.2/include/julia/uv-errno.h
@ -0,0 +1,418 @@
+/* Copyright Joyent, Inc. and other Node contributors. All rights reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to
+ * deal in the Software without restriction, including without limitation the
+ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+ * sell copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+ * IN THE SOFTWARE.
+ */
+
+#ifndef UV_ERRNO_H_
+#define UV_ERRNO_H_
+
+#include <errno.h>
+
+#define UV__EOF     (-4095)
+#define UV__UNKNOWN (-4094)
+
+#define UV__EAI_ADDRFAMILY  (-3000)
+#define UV__EAI_AGAIN       (-3001)
+#define UV__EAI_BADFLAGS    (-3002)
+#define UV__EAI_CANCELED    (-3003)
+#define UV__EAI_FAIL        (-3004)
+#define UV__EAI_FAMILY      (-3005)
+#define UV__EAI_MEMORY      (-3006)
+#define UV__EAI_NODATA      (-3007)
+#define UV__EAI_NONAME      (-3008)
+#define UV__EAI_OVERFLOW    (-3009)
+#define UV__EAI_SERVICE     (-3010)
+#define UV__EAI_SOCKTYPE    (-3011)
+#define UV__EAI_BADHINTS    (-3013)
+#define UV__EAI_PROTOCOL    (-3014)
+
+/* Only map to the system errno on non-Windows platforms. It's apparently
+ * a fairly common practice for Windows programmers to redefine errno codes.
+ */
+#if defined(E2BIG) && !defined(_WIN32)
+# define UV__E2BIG (-E2BIG)
+#else
+# define UV__E2BIG (-4093)
+#endif
+
+#if defined(EACCES) && !defined(_WIN32)
+# define UV__EACCES (-EACCES)
+#else
+# define UV__EACCES (-4092)
+#endif
+
+#if defined(EADDRINUSE) && !defined(_WIN32)
+# define UV__EADDRINUSE (-EADDRINUSE)
+#else
+# define UV__EADDRINUSE (-4091)
+#endif
+
+#if defined(EADDRNOTAVAIL) && !defined(_WIN32)
+# define UV__EADDRNOTAVAIL (-EADDRNOTAVAIL)
+#else
+# define UV__EADDRNOTAVAIL (-4090)
+#endif
+
+#if defined(EAFNOSUPPORT) && !defined(_WIN32)
+# define UV__EAFNOSUPPORT (-EAFNOSUPPORT)
+#else
+# define UV__EAFNOSUPPORT (-4089)
+#endif
+
+#if defined(EAGAIN) && !defined(_WIN32)
+# define UV__EAGAIN (-EAGAIN)
+#else
+# define UV__EAGAIN (-4088)
+#endif
+
+#if defined(EALREADY) && !defined(_WIN32)
+# define UV__EALREADY (-EALREADY)
+#else
+# define UV__EALREADY (-4084)
+#endif
+
+#if defined(EBADF) && !defined(_WIN32)
+# define UV__EBADF (-EBADF)
+#else
+# define UV__EBADF (-4083)
+#endif
+
+#if defined(EBUSY) && !defined(_WIN32)
+# define UV__EBUSY (-EBUSY)
+#else
+# define UV__EBUSY (-4082)
+#endif
+
+#if defined(ECANCELED) && !defined(_WIN32)
+# define UV__ECANCELED (-ECANCELED)
+#else
+# define UV__ECANCELED (-4081)
+#endif
+
+#if defined(ECHARSET) && !defined(_WIN32)
+# define UV__ECHARSET (-ECHARSET)
+#else
+# define UV__ECHARSET (-4080)
+#endif
+
+#if defined(ECONNABORTED) && !defined(_WIN32)
+# define UV__ECONNABORTED (-ECONNABORTED)
+#else
+# define UV__ECONNABORTED (-4079)
+#endif
+
+#if defined(ECONNREFUSED) && !defined(_WIN32)
+# define UV__ECONNREFUSED (-ECONNREFUSED)
+#else
+# define UV__ECONNREFUSED (-4078)
+#endif
+
+#if defined(ECONNRESET) && !defined(_WIN32)
+# define UV__ECONNRESET (-ECONNRESET)
+#else
+# define UV__ECONNRESET (-4077)
+#endif
+
+#if defined(EDESTADDRREQ) && !defined(_WIN32)
+# define UV__EDESTADDRREQ (-EDESTADDRREQ)
+#else
+# define UV__EDESTADDRREQ (-4076)
+#endif
+
+#if defined(EEXIST) && !defined(_WIN32)
+# define UV__EEXIST (-EEXIST)
+#else
+# define UV__EEXIST (-4075)
+#endif
+
+#if defined(EFAULT) && !defined(_WIN32)
+# define UV__EFAULT (-EFAULT)
+#else
+# define UV__EFAULT (-4074)
+#endif
+
+#if defined(EHOSTUNREACH) && !defined(_WIN32)
+# define UV__EHOSTUNREACH (-EHOSTUNREACH)
+#else
+# define UV__EHOSTUNREACH (-4073)
+#endif
+
+#if defined(EINTR) && !defined(_WIN32)
+# define UV__EINTR (-EINTR)
+#else
+# define UV__EINTR (-4072)
+#endif
+
+#if defined(EINVAL) && !defined(_WIN32)
+# define UV__EINVAL (-EINVAL)
+#else
+# define UV__EINVAL (-4071)
+#endif
+
+#if defined(EIO) && !defined(_WIN32)
+# define UV__EIO (-EIO)
+#else
+# define UV__EIO (-4070)
+#endif
+
+#if defined(EISCONN) && !defined(_WIN32)
+# define UV__EISCONN (-EISCONN)
+#else
+# define UV__EISCONN (-4069)
+#endif
+
+#if defined(EISDIR) && !defined(_WIN32)
+# define UV__EISDIR (-EISDIR)
+#else
+# define UV__EISDIR (-4068)
+#endif
+
+#if defined(ELOOP) && !defined(_WIN32)
+# define UV__ELOOP (-ELOOP)
+#else
+# define UV__ELOOP (-4067)
+#endif
+
+#if defined(EMFILE) && !defined(_WIN32)
+# define UV__EMFILE (-EMFILE)
+#else
+# define UV__EMFILE (-4066)
+#endif
+
+#if defined(EMSGSIZE) && !defined(_WIN32)
+# define UV__EMSGSIZE (-EMSGSIZE)
+#else
+# define UV__EMSGSIZE (-4065)
+#endif
+
+#if defined(ENAMETOOLONG) && !defined(_WIN32)
+# define UV__ENAMETOOLONG (-ENAMETOOLONG)
+#else
+# define UV__ENAMETOOLONG (-4064)
+#endif
+
+#if defined(ENETDOWN) && !defined(_WIN32)
+# define UV__ENETDOWN (-ENETDOWN)
+#else
+# define UV__ENETDOWN (-4063)
+#endif
+
+#if defined(ENETUNREACH) && !defined(_WIN32)
+# define UV__ENETUNREACH (-ENETUNREACH)
+#else
+# define UV__ENETUNREACH (-4062)
+#endif
+
+#if defined(ENFILE) && !defined(_WIN32)
+# define UV__ENFILE (-ENFILE)
+#else
+# define UV__ENFILE (-4061)
+#endif
+
+#if defined(ENOBUFS) && !defined(_WIN32)
+# define UV__ENOBUFS (-ENOBUFS)
+#else
+# define UV__ENOBUFS (-4060)
+#endif
+
+#if defined(ENODEV) && !defined(_WIN32)
+# define UV__ENODEV (-ENODEV)
+#else
+# define UV__ENODEV (-4059)
+#endif
+
+#if defined(ENOENT) && !defined(_WIN32)
+# define UV__ENOENT (-ENOENT)
+#else
+# define UV__ENOENT (-4058)
+#endif
+
+#if defined(ENOMEM) && !defined(_WIN32)
+# define UV__ENOMEM (-ENOMEM)
+#else
+# define UV__ENOMEM (-4057)
+#endif
+
+#if defined(ENONET) && !defined(_WIN32)
+# define UV__ENONET (-ENONET)
+#else
+# define UV__ENONET (-4056)
+#endif
+
+#if defined(ENOSPC) && !defined(_WIN32)
+# define UV__ENOSPC (-ENOSPC)
+#else
+# define UV__ENOSPC (-4055)
+#endif
+
+#if defined(ENOSYS) && !defined(_WIN32)
+# define UV__ENOSYS (-ENOSYS)
+#else
+# define UV__ENOSYS (-4054)
+#endif
+
+#if defined(ENOTCONN) && !defined(_WIN32)
+# define UV__ENOTCONN (-ENOTCONN)
+#else
+# define UV__ENOTCONN (-4053)
+#endif
+
+#if defined(ENOTDIR) && !defined(_WIN32)
+# define UV__ENOTDIR (-ENOTDIR)
+#else
+# define UV__ENOTDIR (-4052)
+#endif
+
+#if defined(ENOTEMPTY) && !defined(_WIN32)
+# define UV__ENOTEMPTY (-ENOTEMPTY)
+#else
+# define UV__ENOTEMPTY (-4051)
+#endif
+
+#if defined(ENOTSOCK) && !defined(_WIN32)
+# define UV__ENOTSOCK (-ENOTSOCK)
+#else
+# define UV__ENOTSOCK (-4050)
+#endif
+
+#if defined(ENOTSUP) && !defined(_WIN32)
+# define UV__ENOTSUP (-ENOTSUP)
+#else
+# define UV__ENOTSUP (-4049)
+#endif
+
+#if defined(EPERM) && !defined(_WIN32)
+# define UV__EPERM (-EPERM)
+#else
+# define UV__EPERM (-4048)
+#endif
+
+#if defined(EPIPE) && !defined(_WIN32)
+# define UV__EPIPE (-EPIPE)
+#else
+# define UV__EPIPE (-4047)
+#endif
+
+#if defined(EPROTO) && !defined(_WIN32)
+# define UV__EPROTO (-EPROTO)
+#else
+# define UV__EPROTO (-4046)
+#endif
+
+#if defined(EPROTONOSUPPORT) && !defined(_WIN32)
+# define UV__EPROTONOSUPPORT (-EPROTONOSUPPORT)
+#else
+# define UV__EPROTONOSUPPORT (-4045)
+#endif
+
+#if defined(EPROTOTYPE) && !defined(_WIN32)
+# define UV__EPROTOTYPE (-EPROTOTYPE)
+#else
+# define UV__EPROTOTYPE (-4044)
+#endif
+
+#if defined(EROFS) && !defined(_WIN32)
+# define UV__EROFS (-EROFS)
+#else
+# define UV__EROFS (-4043)
+#endif
+
+#if defined(ESHUTDOWN) && !defined(_WIN32)
+# define UV__ESHUTDOWN (-ESHUTDOWN)
+#else
+# define UV__ESHUTDOWN (-4042)
+#endif
+
+#if defined(ESPIPE) && !defined(_WIN32)
+# define UV__ESPIPE (-ESPIPE)
+#else
+# define UV__ESPIPE (-4041)
+#endif
+
+#if defined(ESRCH) && !defined(_WIN32)
+# define UV__ESRCH (-ESRCH)
+#else
+# define UV__ESRCH (-4040)
+#endif
+
+#if defined(ETIMEDOUT) && !defined(_WIN32)
+# define UV__ETIMEDOUT (-ETIMEDOUT)
+#else
+# define UV__ETIMEDOUT (-4039)
+#endif
+
+#if defined(ETXTBSY) && !defined(_WIN32)
+# define UV__ETXTBSY (-ETXTBSY)
+#else
+# define UV__ETXTBSY (-4038)
+#endif
+
+#if defined(EXDEV) && !defined(_WIN32)
+# define UV__EXDEV (-EXDEV)
+#else
+# define UV__EXDEV (-4037)
+#endif
+
+#if defined(EFBIG) && !defined(_WIN32)
+# define UV__EFBIG (-EFBIG)
+#else
+# define UV__EFBIG (-4036)
+#endif
+
+#if defined(ENOPROTOOPT) && !defined(_WIN32)
+# define UV__ENOPROTOOPT (-ENOPROTOOPT)
+#else
+# define UV__ENOPROTOOPT (-4035)
+#endif
+
+#if defined(ERANGE) && !defined(_WIN32)
+# define UV__ERANGE (-ERANGE)
+#else
+# define UV__ERANGE (-4034)
+#endif
+
+#if defined(ENXIO) && !defined(_WIN32)
+# define UV__ENXIO (-ENXIO)
+#else
+# define UV__ENXIO (-4033)
+#endif
+
+#if defined(EMLINK) && !defined(_WIN32)
+# define UV__EMLINK (-EMLINK)
+#else
+# define UV__EMLINK (-4032)
+#endif
+
+/* EHOSTDOWN is not visible on BSD-like systems when _POSIX_C_SOURCE is
+ * defined. Fortunately, its value is always 64 so it's possible albeit
+ * icky to hard-code it.
+ */
+#if defined(EHOSTDOWN) && !defined(_WIN32)
+# define UV__EHOSTDOWN (-EHOSTDOWN)
+#elif defined(__APPLE__) || \
+      defined(__DragonFly__) || \
+      defined(__FreeBSD__) || \
+      defined(__NetBSD__) || \
+      defined(__OpenBSD__)
+# define UV__EHOSTDOWN (-64)
+#else
+# define UV__EHOSTDOWN (-4031)
+#endif
+
+#endif /* UV_ERRNO_H_ */
--- a/julia-0.6.2/include/julia/uv-linux.h
+++ b/julia-0.6.2/include/julia/uv-linux.h
@ -0,0 +1,34 @@
+/* Copyright Joyent, Inc. and other Node contributors. All rights reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to
+ * deal in the Software without restriction, including without limitation the
+ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+ * sell copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+ * IN THE SOFTWARE.
+ */
+
+#ifndef UV_LINUX_H
+#define UV_LINUX_H
+
+#define UV_PLATFORM_LOOP_FIELDS                                               \
+  uv__io_t inotify_read_watcher;                                              \
+  void* inotify_watchers;                                                     \
+  int inotify_fd;                                                             \
+
+#define UV_PLATFORM_FS_EVENT_FIELDS                                           \
+  void* watchers[2];                                                          \
+  int wd;                                                                     \
+
+#endif /* UV_LINUX_H */
--- a/julia-0.6.2/include/julia/uv-threadpool.h
+++ b/julia-0.6.2/include/julia/uv-threadpool.h
@ -0,0 +1,37 @@
+/* Copyright Joyent, Inc. and other Node contributors. All rights reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to
+ * deal in the Software without restriction, including without limitation the
+ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+ * sell copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+ * IN THE SOFTWARE.
+ */
+
+/*
+ * This file is private to libuv. It provides common functionality to both
+ * Windows and Unix backends.
+ */
+
+#ifndef UV_THREADPOOL_H_
+#define UV_THREADPOOL_H_
+
+struct uv__work {
+  void (*work)(struct uv__work *w);
+  void (*done)(struct uv__work *w, int status);
+  struct uv_loop_s* loop;
+  void* wq[2];
+};
+
+#endif /* UV_THREADPOOL_H_ */
--- a/julia-0.6.2/include/julia/uv-unix.h
+++ b/julia-0.6.2/include/julia/uv-unix.h
@ -0,0 +1,384 @@
+/* Copyright Joyent, Inc. and other Node contributors. All rights reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to
+ * deal in the Software without restriction, including without limitation the
+ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+ * sell copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+ * IN THE SOFTWARE.
+ */
+
+#ifndef UV_UNIX_H
+#define UV_UNIX_H
+
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <dirent.h>
+
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <netinet/tcp.h>
+#include <arpa/inet.h>
+#include <netdb.h>
+
+#include <termios.h>
+#include <pwd.h>
+
+#include <semaphore.h>
+#include <pthread.h>
+#include <sched.h>
+#ifdef __ANDROID__
+#include "pthread-fixes.h"
+#endif
+#include <signal.h>
+
+#include "uv-threadpool.h"
+
+#if defined(__linux__)
+# include "uv-linux.h"
+#elif defined(_AIX)
+# include "uv-aix.h"
+#elif defined(__sun)
+# include "uv-sunos.h"
+#elif defined(__APPLE__)
+# include "uv-darwin.h"
+#elif defined(__DragonFly__)  || \
+      defined(__FreeBSD__)    || \
+      defined(__OpenBSD__)    || \
+      defined(__NetBSD__)
+# include "uv-bsd.h"
+#endif
+
+#ifndef NI_MAXHOST
+# define NI_MAXHOST 1025
+#endif
+
+#ifndef NI_MAXSERV
+# define NI_MAXSERV 32
+#endif
+
+#ifndef UV_IO_PRIVATE_PLATFORM_FIELDS
+# define UV_IO_PRIVATE_PLATFORM_FIELDS /* empty */
+#endif
+
+struct uv__io_s;
+struct uv__async;
+struct uv_loop_s;
+
+typedef void (*uv__io_cb)(struct uv_loop_s* loop,
+                          struct uv__io_s* w,
+                          unsigned int events);
+typedef struct uv__io_s uv__io_t;
+
+struct uv__io_s {
+  uv__io_cb cb;
+  void* pending_queue[2];
+  void* watcher_queue[2];
+  unsigned int pevents; /* Pending event mask i.e. mask at next tick. */
+  unsigned int events;  /* Current event mask. */
+  int fd;
+  UV_IO_PRIVATE_PLATFORM_FIELDS
+};
+
+typedef void (*uv__async_cb)(struct uv_loop_s* loop,
+                             struct uv__async* w,
+                             unsigned int nevents);
+
+struct uv__async {
+  uv__async_cb cb;
+  uv__io_t io_watcher;
+  int wfd;
+};
+
+#ifndef UV_PLATFORM_SEM_T
+# define UV_PLATFORM_SEM_T sem_t
+#endif
+
+#ifndef UV_PLATFORM_LOOP_FIELDS
+# define UV_PLATFORM_LOOP_FIELDS /* empty */
+#endif
+
+#ifndef UV_PLATFORM_FS_EVENT_FIELDS
+# define UV_PLATFORM_FS_EVENT_FIELDS /* empty */
+#endif
+
+#ifndef UV_STREAM_PRIVATE_PLATFORM_FIELDS
+# define UV_STREAM_PRIVATE_PLATFORM_FIELDS /* empty */
+#endif
+
+/* Note: May be cast to struct iovec. See writev(2). */
+typedef struct uv_buf_t {
+  char* base;
+  size_t len;
+} uv_buf_t;
+
+typedef int uv_file;
+typedef int uv_os_sock_t;
+typedef int uv_os_fd_t;
+
+#define UV_ONCE_INIT PTHREAD_ONCE_INIT
+
+typedef pthread_once_t uv_once_t;
+typedef pthread_t uv_thread_t;
+typedef pthread_mutex_t uv_mutex_t;
+typedef pthread_rwlock_t uv_rwlock_t;
+typedef UV_PLATFORM_SEM_T uv_sem_t;
+typedef pthread_cond_t uv_cond_t;
+typedef pthread_key_t uv_key_t;
+
+#if defined(__APPLE__) && defined(__MACH__)
+
+typedef struct {
+  unsigned int n;
+  unsigned int count;
+  uv_mutex_t mutex;
+  uv_sem_t turnstile1;
+  uv_sem_t turnstile2;
+} uv_barrier_t;
+
+#else /* defined(__APPLE__) && defined(__MACH__) */
+
+typedef pthread_barrier_t uv_barrier_t;
+
+#endif /* defined(__APPLE__) && defined(__MACH__) */
+
+/* Platform-specific definitions for uv_spawn support. */
+typedef gid_t uv_gid_t;
+typedef uid_t uv_uid_t;
+
+typedef struct dirent uv__dirent_t;
+
+#if defined(DT_UNKNOWN)
+# define HAVE_DIRENT_TYPES
+# if defined(DT_REG)
+#  define UV__DT_FILE DT_REG
+# else
+#  define UV__DT_FILE -1
+# endif
+# if defined(DT_DIR)
+#  define UV__DT_DIR DT_DIR
+# else
+#  define UV__DT_DIR -2
+# endif
+# if defined(DT_LNK)
+#  define UV__DT_LINK DT_LNK
+# else
+#  define UV__DT_LINK -3
+# endif
+# if defined(DT_FIFO)
+#  define UV__DT_FIFO DT_FIFO
+# else
+#  define UV__DT_FIFO -4
+# endif
+# if defined(DT_SOCK)
+#  define UV__DT_SOCKET DT_SOCK
+# else
+#  define UV__DT_SOCKET -5
+# endif
+# if defined(DT_CHR)
+#  define UV__DT_CHAR DT_CHR
+# else
+#  define UV__DT_CHAR -6
+# endif
+# if defined(DT_BLK)
+#  define UV__DT_BLOCK DT_BLK
+# else
+#  define UV__DT_BLOCK -7
+# endif
+#endif
+
+/* Platform-specific definitions for uv_dlopen support. */
+#define UV_DYNAMIC /* empty */
+
+typedef struct {
+  void* handle;
+  char* errmsg;
+} uv_lib_t;
+
+#define UV_LOOP_PRIVATE_FIELDS                                                \
+  unsigned long flags;                                                        \
+  int backend_fd;                                                             \
+  void* pending_queue[2];                                                     \
+  void* watcher_queue[2];                                                     \
+  uv__io_t** watchers;                                                        \
+  unsigned int nwatchers;                                                     \
+  unsigned int nfds;                                                          \
+  void* wq[2];                                                                \
+  uv_mutex_t wq_mutex;                                                        \
+  uv_async_t wq_async;                                                        \
+  uv_rwlock_t cloexec_lock;                                                   \
+  uv_handle_t* closing_handles;                                               \
+  void* process_handles[2];                                                   \
+  void* prepare_handles[2];                                                   \
+  void* check_handles[2];                                                     \
+  void* idle_handles[2];                                                      \
+  void* async_handles[2];                                                     \
+  struct uv__async async_watcher;                                             \
+  struct {                                                                    \
+    void* min;                                                                \
+    unsigned int nelts;                                                       \
+  } timer_heap;                                                               \
+  uint64_t timer_counter;                                                     \
+  uint64_t time;                                                              \
+  int signal_pipefd[2];                                                       \
+  uv__io_t signal_io_watcher;                                                 \
+  uv_signal_t child_watcher;                                                  \
+  int emfile_fd;                                                              \
+  UV_PLATFORM_LOOP_FIELDS                                                     \
+
+#define UV_REQ_TYPE_PRIVATE /* empty */
+
+#define UV_REQ_PRIVATE_FIELDS  /* empty */
+
+#define UV_PRIVATE_REQ_TYPES /* empty */
+
+#define UV_WRITE_PRIVATE_FIELDS                                               \
+  void* queue[2];                                                             \
+  unsigned int write_index;                                                   \
+  uv_buf_t* bufs;                                                             \
+  unsigned int nbufs;                                                         \
+  int error;                                                                  \
+  uv_buf_t bufsml[4];                                                         \
+
+#define UV_CONNECT_PRIVATE_FIELDS                                             \
+  void* queue[2];                                                             \
+
+#define UV_SHUTDOWN_PRIVATE_FIELDS /* empty */
+
+#define UV_UDP_SEND_PRIVATE_FIELDS                                            \
+  void* queue[2];                                                             \
+  struct sockaddr_storage addr;                                               \
+  unsigned int nbufs;                                                         \
+  uv_buf_t* bufs;                                                             \
+  ssize_t status;                                                             \
+  uv_udp_send_cb send_cb;                                                     \
+  uv_buf_t bufsml[4];                                                         \
+
+#define UV_HANDLE_PRIVATE_FIELDS                                              \
+  uv_handle_t* next_closing;                                                  \
+  unsigned int flags;                                                         \
+
+#define UV_STREAM_PRIVATE_FIELDS                                              \
+  uv_connect_t *connect_req;                                                  \
+  uv_shutdown_t *shutdown_req;                                                \
+  uv__io_t io_watcher;                                                        \
+  void* write_queue[2];                                                       \
+  void* write_completed_queue[2];                                             \
+  uv_connection_cb connection_cb;                                             \
+  int delayed_error;                                                          \
+  int accepted_fd;                                                            \
+  void* queued_fds;                                                           \
+  UV_STREAM_PRIVATE_PLATFORM_FIELDS                                           \
+
+#define UV_TCP_PRIVATE_FIELDS /* empty */
+
+#define UV_UDP_PRIVATE_FIELDS                                                 \
+  uv_alloc_cb alloc_cb;                                                       \
+  uv_udp_recv_cb recv_cb;                                                     \
+  uv__io_t io_watcher;                                                        \
+  void* write_queue[2];                                                       \
+  void* write_completed_queue[2];                                             \
+
+#define UV_PIPE_PRIVATE_FIELDS                                                \
+  const char* pipe_fname; /* strdup'ed */
+
+#define UV_POLL_PRIVATE_FIELDS                                                \
+  uv__io_t io_watcher;
+
+#define UV_PREPARE_PRIVATE_FIELDS                                             \
+  uv_prepare_cb prepare_cb;                                                   \
+  void* queue[2];                                                             \
+
+#define UV_CHECK_PRIVATE_FIELDS                                               \
+  uv_check_cb check_cb;                                                       \
+  void* queue[2];                                                             \
+
+#define UV_IDLE_PRIVATE_FIELDS                                                \
+  uv_idle_cb idle_cb;                                                         \
+  void* queue[2];                                                             \
+
+#define UV_ASYNC_PRIVATE_FIELDS                                               \
+  uv_async_cb async_cb;                                                       \
+  void* queue[2];                                                             \
+  int pending;                                                                \
+
+#define UV_TIMER_PRIVATE_FIELDS                                               \
+  uv_timer_cb timer_cb;                                                       \
+  void* heap_node[3];                                                         \
+  uint64_t timeout;                                                           \
+  uint64_t repeat;                                                            \
+  uint64_t start_id;
+
+#define UV_GETADDRINFO_PRIVATE_FIELDS                                         \
+  struct uv__work work_req;                                                   \
+  uv_getaddrinfo_cb cb;                                                       \
+  struct addrinfo* hints;                                                     \
+  char* hostname;                                                             \
+  char* service;                                                              \
+  struct addrinfo* addrinfo;                                                  \
+  int retcode;
+
+#define UV_GETNAMEINFO_PRIVATE_FIELDS                                         \
+  struct uv__work work_req;                                                   \
+  uv_getnameinfo_cb getnameinfo_cb;                                           \
+  struct sockaddr_storage storage;                                            \
+  int flags;                                                                  \
+  char host[NI_MAXHOST];                                                      \
+  char service[NI_MAXSERV];                                                   \
+  int retcode;
+
+#define UV_PROCESS_PRIVATE_FIELDS                                             \
+  void* queue[2];                                                             \
+  int status;                                                                 \
+
+#define UV_FS_PRIVATE_FIELDS                                                  \
+  const char *new_path;                                                       \
+  uv_file file;                                                               \
+  int flags;                                                                  \
+  mode_t mode;                                                                \
+  unsigned int nbufs;                                                         \
+  uv_buf_t* bufs;                                                             \
+  off_t off;                                                                  \
+  uv_uid_t uid;                                                               \
+  uv_gid_t gid;                                                               \
+  double atime;                                                               \
+  double mtime;                                                               \
+  struct uv__work work_req;                                                   \
+  uv_buf_t bufsml[4];                                                         \
+
+#define UV_WORK_PRIVATE_FIELDS                                                \
+  struct uv__work work_req;
+
+#define UV_TTY_PRIVATE_FIELDS                                                 \
+  struct termios orig_termios;                                                \
+  int mode;
+
+#define UV_SIGNAL_PRIVATE_FIELDS                                              \
+  /* RB_ENTRY(uv_signal_s) tree_entry; */                                     \
+  struct {                                                                    \
+    struct uv_signal_s* rbe_left;                                             \
+    struct uv_signal_s* rbe_right;                                            \
+    struct uv_signal_s* rbe_parent;                                           \
+    int rbe_color;                                                            \
+  } tree_entry;                                                               \
+  /* Use two counters here so we don have to fiddle with atomics. */          \
+  unsigned int caught_signals;                                                \
+  unsigned int dispatched_signals;
+
+#define UV_FS_EVENT_PRIVATE_FIELDS                                            \
+  uv_fs_event_cb cb;                                                          \
+  UV_PLATFORM_FS_EVENT_FIELDS                                                 \
+
+#endif /* UV_UNIX_H */
--- a/julia-0.6.2/include/julia/uv-version.h
+++ b/julia-0.6.2/include/julia/uv-version.h
@ -0,0 +1,43 @@
+/* Copyright Joyent, Inc. and other Node contributors. All rights reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to
+ * deal in the Software without restriction, including without limitation the
+ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+ * sell copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+ * IN THE SOFTWARE.
+ */
+
+#ifndef UV_VERSION_H
+#define UV_VERSION_H
+
+ /*
+ * Versions with the same major number are ABI stable. API is allowed to
+ * evolve between minor releases, but only in a backwards compatible way.
+ * Make sure you update the -soname directives in configure.ac
+ * and uv.gyp whenever you bump UV_VERSION_MAJOR or UV_VERSION_MINOR (but
+ * not UV_VERSION_PATCH.)
+ */
+
+#define UV_VERSION_MAJOR 1
+#define UV_VERSION_MINOR 9
+#define UV_VERSION_PATCH 0
+#define UV_VERSION_IS_RELEASE 1
+#define UV_VERSION_SUFFIX ""
+
+#define UV_VERSION_HEX  ((UV_VERSION_MAJOR << 16) | \
+                         (UV_VERSION_MINOR <<  8) | \
+                         (UV_VERSION_PATCH))
+
+#endif /* UV_VERSION_H */
--- a/julia-0.6.2/include/julia/uv.h
+++ b/julia-0.6.2/include/julia/uv.h
--- a/julia-0.6.2/lib/julia/libLLVM-3.9.1.so
+++ b/julia-0.6.2/lib/julia/libLLVM-3.9.1.so
@ -0,0 +1 @@
+libLLVM-3.9.so
--- a/julia-0.6.2/lib/julia/libLLVM-3.9.so.REMOVED.git-id
+++ b/julia-0.6.2/lib/julia/libLLVM-3.9.so.REMOVED.git-id
@ -0,0 +1 @@
+173da2407f070e4c4947732c7bbed9c8abb0727b
--- a/julia-0.6.2/lib/julia/libLLVM.so
+++ b/julia-0.6.2/lib/julia/libLLVM.so
@ -0,0 +1 @@
+libLLVM-3.9.so
--- a/julia-0.6.2/lib/julia/libamd.so
+++ b/julia-0.6.2/lib/julia/libamd.so
--- a/julia-0.6.2/lib/julia/libarpack.so
+++ b/julia-0.6.2/lib/julia/libarpack.so
@ -0,0 +1 @@
+libarpack.so.2.0.0
--- a/julia-0.6.2/lib/julia/libarpack.so.2
+++ b/julia-0.6.2/lib/julia/libarpack.so.2
@ -0,0 +1 @@
+libarpack.so.2.0.0
--- a/julia-0.6.2/lib/julia/libarpack.so.2.0.0
+++ b/julia-0.6.2/lib/julia/libarpack.so.2.0.0
--- a/julia-0.6.2/lib/julia/libcamd.so
+++ b/julia-0.6.2/lib/julia/libcamd.so
--- a/julia-0.6.2/lib/julia/libccalltest.so
+++ b/julia-0.6.2/lib/julia/libccalltest.so
--- a/julia-0.6.2/lib/julia/libccalltest.so.debug
+++ b/julia-0.6.2/lib/julia/libccalltest.so.debug
--- a/julia-0.6.2/lib/julia/libccolamd.so
+++ b/julia-0.6.2/lib/julia/libccolamd.so
--- a/julia-0.6.2/lib/julia/libcholmod.so
+++ b/julia-0.6.2/lib/julia/libcholmod.so
--- a/julia-0.6.2/lib/julia/libcolamd.so
+++ b/julia-0.6.2/lib/julia/libcolamd.so
--- a/julia-0.6.2/lib/julia/libcurl.so
+++ b/julia-0.6.2/lib/julia/libcurl.so
@ -0,0 +1 @@
+libcurl.so.4.5.0
--- a/julia-0.6.2/lib/julia/libcurl.so.4
+++ b/julia-0.6.2/lib/julia/libcurl.so.4
@ -0,0 +1 @@
+libcurl.so.4.5.0
--- a/julia-0.6.2/lib/julia/libcurl.so.4.5.0
+++ b/julia-0.6.2/lib/julia/libcurl.so.4.5.0
--- a/julia-0.6.2/lib/julia/libdSFMT.so
+++ b/julia-0.6.2/lib/julia/libdSFMT.so
--- a/julia-0.6.2/lib/julia/libfftw3.so
+++ b/julia-0.6.2/lib/julia/libfftw3.so
@ -0,0 +1 @@
+libfftw3.so.3.5.6
--- a/julia-0.6.2/lib/julia/libfftw3.so.3
+++ b/julia-0.6.2/lib/julia/libfftw3.so.3
@ -0,0 +1 @@
+libfftw3.so.3.5.6
--- a/julia-0.6.2/lib/julia/libfftw3.so.3.5.6
+++ b/julia-0.6.2/lib/julia/libfftw3.so.3.5.6
--- a/julia-0.6.2/lib/julia/libfftw3_threads.so
+++ b/julia-0.6.2/lib/julia/libfftw3_threads.so
@ -0,0 +1 @@
+libfftw3_threads.so.3.5.6
--- a/julia-0.6.2/lib/julia/libfftw3_threads.so.3
+++ b/julia-0.6.2/lib/julia/libfftw3_threads.so.3
@ -0,0 +1 @@
+libfftw3_threads.so.3.5.6
--- a/julia-0.6.2/lib/julia/libfftw3_threads.so.3.5.6
+++ b/julia-0.6.2/lib/julia/libfftw3_threads.so.3.5.6
--- a/julia-0.6.2/lib/julia/libfftw3f.so
+++ b/julia-0.6.2/lib/julia/libfftw3f.so
@ -0,0 +1 @@
+libfftw3f.so.3.5.6
--- a/julia-0.6.2/lib/julia/libfftw3f.so.3
+++ b/julia-0.6.2/lib/julia/libfftw3f.so.3
@ -0,0 +1 @@
+libfftw3f.so.3.5.6
--- a/julia-0.6.2/lib/julia/libfftw3f.so.3.5.6
+++ b/julia-0.6.2/lib/julia/libfftw3f.so.3.5.6
--- a/julia-0.6.2/lib/julia/libfftw3f_threads.so
+++ b/julia-0.6.2/lib/julia/libfftw3f_threads.so
@ -0,0 +1 @@
+libfftw3f_threads.so.3.5.6
--- a/julia-0.6.2/lib/julia/libfftw3f_threads.so.3
+++ b/julia-0.6.2/lib/julia/libfftw3f_threads.so.3
@ -0,0 +1 @@
+libfftw3f_threads.so.3.5.6
--- a/julia-0.6.2/lib/julia/libfftw3f_threads.so.3.5.6
+++ b/julia-0.6.2/lib/julia/libfftw3f_threads.so.3.5.6
--- a/julia-0.6.2/lib/julia/libgcc_s.so.1
+++ b/julia-0.6.2/lib/julia/libgcc_s.so.1
--- a/julia-0.6.2/lib/julia/libgfortran.so.4
+++ b/julia-0.6.2/lib/julia/libgfortran.so.4
--- a/julia-0.6.2/lib/julia/libgit2.so
+++ b/julia-0.6.2/lib/julia/libgit2.so
@ -0,0 +1 @@
+libgit2.so.25
--- a/julia-0.6.2/lib/julia/libgit2.so.0.25.1
+++ b/julia-0.6.2/lib/julia/libgit2.so.0.25.1
--- a/julia-0.6.2/lib/julia/libgit2.so.25
+++ b/julia-0.6.2/lib/julia/libgit2.so.25
@ -0,0 +1 @@
+libgit2.so.0.25.1
--- a/julia-0.6.2/lib/julia/libgmp.so
+++ b/julia-0.6.2/lib/julia/libgmp.so
@ -0,0 +1 @@
+libgmp.so.10.3.2
--- a/julia-0.6.2/lib/julia/libgmp.so.10
+++ b/julia-0.6.2/lib/julia/libgmp.so.10
@ -0,0 +1 @@
+libgmp.so.10.3.2
--- a/julia-0.6.2/lib/julia/libgmp.so.10.3.2
+++ b/julia-0.6.2/lib/julia/libgmp.so.10.3.2
--- a/julia-0.6.2/lib/julia/libmbedcrypto.so
+++ b/julia-0.6.2/lib/julia/libmbedcrypto.so
@ -0,0 +1 @@
+libmbedcrypto.so.0
--- a/julia-0.6.2/lib/julia/libmbedcrypto.so.0
+++ b/julia-0.6.2/lib/julia/libmbedcrypto.so.0
@ -0,0 +1 @@
+libmbedcrypto.so.2.3.0
--- a/julia-0.6.2/lib/julia/libmbedcrypto.so.2.3.0
+++ b/julia-0.6.2/lib/julia/libmbedcrypto.so.2.3.0
--- a/julia-0.6.2/lib/julia/libmbedtls.so
+++ b/julia-0.6.2/lib/julia/libmbedtls.so
@ -0,0 +1 @@
+libmbedtls.so.10
--- a/julia-0.6.2/lib/julia/libmbedtls.so.10
+++ b/julia-0.6.2/lib/julia/libmbedtls.so.10
@ -0,0 +1 @@
+libmbedtls.so.2.3.0
--- a/julia-0.6.2/lib/julia/libmbedtls.so.2.3.0
+++ b/julia-0.6.2/lib/julia/libmbedtls.so.2.3.0
--- a/julia-0.6.2/lib/julia/libmbedx509.so
+++ b/julia-0.6.2/lib/julia/libmbedx509.so
@ -0,0 +1 @@
+libmbedx509.so.0
--- a/julia-0.6.2/lib/julia/libmbedx509.so.0
+++ b/julia-0.6.2/lib/julia/libmbedx509.so.0
@ -0,0 +1 @@
+libmbedx509.so.2.3.0
--- a/julia-0.6.2/lib/julia/libmbedx509.so.2.3.0
+++ b/julia-0.6.2/lib/julia/libmbedx509.so.2.3.0
--- a/julia-0.6.2/lib/julia/libmpfr.so
+++ b/julia-0.6.2/lib/julia/libmpfr.so
@ -0,0 +1 @@
+libmpfr.so.4.1.5
--- a/julia-0.6.2/lib/julia/libmpfr.so.4
+++ b/julia-0.6.2/lib/julia/libmpfr.so.4
@ -0,0 +1 @@
+libmpfr.so.4.1.5
--- a/julia-0.6.2/lib/julia/libmpfr.so.4.1.5
+++ b/julia-0.6.2/lib/julia/libmpfr.so.4.1.5
--- a/julia-0.6.2/lib/julia/libopenblas64_.so.0
+++ b/julia-0.6.2/lib/julia/libopenblas64_.so.0
@ -0,0 +1 @@
+libopenblas64_.so
--- a/julia-0.6.2/lib/julia/libopenblas64_.so.REMOVED.git-id
+++ b/julia-0.6.2/lib/julia/libopenblas64_.so.REMOVED.git-id
@ -0,0 +1 @@
+c4107e0b3adc180eb0fcff4a80b11a4158eeee7f
--- a/julia-0.6.2/lib/julia/libopenlibm.so
+++ b/julia-0.6.2/lib/julia/libopenlibm.so
@ -0,0 +1 @@
+libopenlibm.so.2.3
--- a/julia-0.6.2/lib/julia/libopenlibm.so.2
+++ b/julia-0.6.2/lib/julia/libopenlibm.so.2
@ -0,0 +1 @@
+libopenlibm.so.2.3
--- a/julia-0.6.2/lib/julia/libopenlibm.so.2.3
+++ b/julia-0.6.2/lib/julia/libopenlibm.so.2.3
--- a/julia-0.6.2/lib/julia/libopenspecfun.so
+++ b/julia-0.6.2/lib/julia/libopenspecfun.so
@ -0,0 +1 @@
+libopenspecfun.so.1.3
--- a/julia-0.6.2/lib/julia/libopenspecfun.so.1
+++ b/julia-0.6.2/lib/julia/libopenspecfun.so.1
@ -0,0 +1 @@
+libopenspecfun.so.1.3
--- a/julia-0.6.2/lib/julia/libopenspecfun.so.1.3
+++ b/julia-0.6.2/lib/julia/libopenspecfun.so.1.3
--- a/julia-0.6.2/lib/julia/libpcre2-8.so
+++ b/julia-0.6.2/lib/julia/libpcre2-8.so
@ -0,0 +1 @@
+libpcre2-8.so.0.5.0
--- a/julia-0.6.2/lib/julia/libpcre2-8.so.0
+++ b/julia-0.6.2/lib/julia/libpcre2-8.so.0
@ -0,0 +1 @@
+libpcre2-8.so.0.5.0
--- a/julia-0.6.2/lib/julia/libpcre2-8.so.0.5.0
+++ b/julia-0.6.2/lib/julia/libpcre2-8.so.0.5.0
--- a/julia-0.6.2/lib/julia/libpcre2-posix.so
+++ b/julia-0.6.2/lib/julia/libpcre2-posix.so
@ -0,0 +1 @@
+libpcre2-posix.so.1.0.1
--- a/julia-0.6.2/lib/julia/libpcre2-posix.so.1
+++ b/julia-0.6.2/lib/julia/libpcre2-posix.so.1
@ -0,0 +1 @@
+libpcre2-posix.so.1.0.1
--- a/julia-0.6.2/lib/julia/libpcre2-posix.so.1.0.1
+++ b/julia-0.6.2/lib/julia/libpcre2-posix.so.1.0.1
--- a/julia-0.6.2/lib/julia/libquadmath.so.0
+++ b/julia-0.6.2/lib/julia/libquadmath.so.0
--- a/julia-0.6.2/lib/julia/libspqr.so
+++ b/julia-0.6.2/lib/julia/libspqr.so
--- a/julia-0.6.2/lib/julia/libssh2.so
+++ b/julia-0.6.2/lib/julia/libssh2.so
@ -0,0 +1 @@
+libssh2.so.1
--- a/julia-0.6.2/lib/julia/libssh2.so.1
+++ b/julia-0.6.2/lib/julia/libssh2.so.1
@ -0,0 +1 @@
+libssh2.so.1.0.1
--- a/Show More
+++ b/Show More