Set version to 0.26.3-sp1

* Proper shutdown for ssl and non-ssl connections
* Report session id in history
* Report histogram of requests per session
* Change print name to 'http'
* Split logging into "HTTP" and "HTTP-RPC" partitions
* More logging and refinement of logging severities
* Log the request count when a session is destroyed

Conflicts:
	src/ripple/http/impl/Peer.cpp
	src/ripple/http/impl/Peer.h
	src/ripple/http/impl/ServerImpl.cpp
	src/ripple/module/app/main/Application.cpp
	src/ripple/module/app/main/RPCHTTPServer.cpp

.gitattributes

@@ -1,5 +1,5 @@
 # Set default behaviour, in case users don't have core.autocrlf set.
-* text=auto
+#* text=auto
 
 # These annoying files
 rippled.1 binary

.gitignore

@@ -19,6 +19,7 @@
 *.o
 build
 tags
+TAGS
 bin/rippled
 Debug/*.*
 Release/*.*
@@ -72,3 +73,6 @@ My Amplifier XE Results - RippleD
 
 # Compiler intermediate output
 /out.txt
+
+# Build Log
+rippled-build.log

.travis.yml

@@ -12,6 +12,14 @@ before_install:
   - sudo apt-get install -qq libboost1.55-all-dev 
   # We want debug symbols for boost as we install gdb later
   - sudo apt-get install -qq libboost1.55-dbg
+  - | # Setup the BOOST_ROOT
+      export BOOST_ROOT=$HOME/boost_root
+      mkdir -p $BOOST_ROOT/stage
+      ln -s /usr/lib/x86_64-linux-gnu $BOOST_ROOT/stage/lib
+      ln -s /usr/include/boost $BOOST_ROOT/boost
+  - | # Try to patch boost
+      sudo patch /usr/include/boost/bimap/detail/debug/static_error.hpp Builds/travis/static_error.boost.patch
+      sudo patch /usr/include/boost/config/compiler/clang.hpp Builds/travis/clang.boost.patch
   - sudo apt-get install -qq mlocate
   - sudo updatedb
   - sudo locate libboost | grep /lib | grep -e ".a$"
@@ -41,7 +49,7 @@ script:
     echo "run" >> script.gdb
     echo "backtrace full" >> script.gdb 
     # gdb --help
-  - cat script.gdb | gdb --return-child-result --args ./build/rippled --unittest 
+  - cat script.gdb | gdb --ex 'set print thread-events off' --return-child-result --args ./build/rippled --unittest 
   # Run integration tests
   - npm install
   - npm test

Builds/ArchLinux/PKGBUILD

@@ -0,0 +1,41 @@
+# Maintainer: Roberto Catini <roberto.catini@gmail.com> 
+
+pkgname=rippled
+pkgrel=1
+pkgver=0
+pkgdesc="Ripple peer-to-peer network daemon"
+arch=('i686' 'x86_64')
+url="https://github.com/ripple/rippled"
+license=('custom:ISC')
+depends=('protobuf' 'openssl' 'boost-libs')
+makedepends=('git' 'scons' 'boost')
+checkdepends=('nodejs')
+backup=("etc/$pkgname/rippled.cfg")
+source=("git://github.com/ripple/rippled.git#branch=master")
+sha512sums=('SKIP')
+
+pkgver() {
+	cd "$srcdir/$pkgname"
+	git describe --long --tags | sed -r 's/([^-]*-g)/r\1/;s/-/./g'
+}
+
+build() {
+	cd "$srcdir/$pkgname"
+	scons build/rippled
+}
+
+check() {
+	cd "$srcdir/$pkgname"
+	npm install
+	npm test
+	build/rippled --unittest
+}
+
+package() {
+	cd "$srcdir/$pkgname"
+	install -D -m644 LICENSE "$pkgdir/usr/share/licenses/$pkgname/LICENSE"
+	install -D build/rippled "$pkgdir/usr/bin/rippled"
+	install -D -m644 doc/rippled-example.cfg "$pkgdir/etc/$pkgname/rippled.cfg"
+	mkdir -p "$pkgdir/var/lib/$pkgname/db"
+	mkdir -p "$pkgdir/var/log/$pkgname"
+}

Builds/Docker/Dockerfile

@@ -0,0 +1,30 @@
+# rippled
+
+# use the ubuntu base image
+FROM ubuntu
+MAINTAINER Roberto Catini roberto.catini@gmail.com
+
+# make sure the package repository is up to date
+RUN apt-get update
+RUN apt-get -y upgrade
+
+# install the dependencies
+RUN apt-get -y install git scons pkg-config protobuf-compiler libprotobuf-dev libssl-dev libboost1.55-all-dev
+
+# download source code from official repository
+RUN git clone https://github.com/ripple/rippled.git src; cd src/; git checkout master
+
+# compile
+RUN cd src/; scons build/rippled
+
+# move to root directory and strip
+RUN cp src/build/rippled rippled; strip rippled
+
+# copy default config
+RUN cp src/doc/rippled-example.cfg rippled.cfg
+
+# clean source
+RUN rm -r src
+
+# launch rippled when launching the container
+ENTRYPOINT ./rippled

Builds/QtCreator/rippled.pro

@@ -45,7 +45,6 @@ linux-g++:QMAKE_CXXFLAGS += \
     -pthread
 
 INCLUDEPATH += \
-    "../../src" \
     "../../src/leveldb/" \
     "../../src/leveldb/port" \
     "../../src/leveldb/include" \
@@ -63,42 +62,42 @@ UI_HEADERS_DIR += ../../src/ripple_basics
 # New style
 #
 SOURCES += \
-    ../../src/ripple/beast/ripple_beast.cpp \
+    ../../src/ripple/beast/ripple_beast.unity.cpp \
     ../../src/ripple/beast/ripple_beastc.c \
-    ../../src/ripple/common/ripple_common.cpp \
-    ../../src/ripple/http/ripple_http.cpp \
-    ../../src/ripple/json/ripple_json.cpp \
-    ../../src/ripple/peerfinder/ripple_peerfinder.cpp \
-    ../../src/ripple/radmap/ripple_radmap.cpp \
-    ../../src/ripple/resource/ripple_resource.cpp \
-    ../../src/ripple/sitefiles/ripple_sitefiles.cpp \
-    ../../src/ripple/sslutil/ripple_sslutil.cpp \
-    ../../src/ripple/testoverlay/ripple_testoverlay.cpp \
-    ../../src/ripple/types/ripple_types.cpp \
-    ../../src/ripple/validators/ripple_validators.cpp
+    ../../src/ripple/common/ripple_common.unity.cpp \
+    ../../src/ripple/http/ripple_http.unity.cpp \
+    ../../src/ripple/json/ripple_json.unity.cpp \
+    ../../src/ripple/peerfinder/ripple_peerfinder.unity.cpp \
+    ../../src/ripple/radmap/ripple_radmap.unity.cpp \
+    ../../src/ripple/resource/ripple_resource.unity.cpp \
+    ../../src/ripple/sitefiles/ripple_sitefiles.unity.cpp \
+    ../../src/ripple/sslutil/ripple_sslutil.unity.cpp \
+    ../../src/ripple/testoverlay/ripple_testoverlay.unity.cpp \
+    ../../src/ripple/types/ripple_types.unity.cpp \
+    ../../src/ripple/validators/ripple_validators.unity.cpp
 
 # ---------
 # Old style
 #
 SOURCES += \
-    ../../src/ripple_app/ripple_app.cpp \
-    ../../src/ripple_app/ripple_app_pt1.cpp \
-    ../../src/ripple_app/ripple_app_pt2.cpp \
-    ../../src/ripple_app/ripple_app_pt3.cpp \
-    ../../src/ripple_app/ripple_app_pt4.cpp \
-    ../../src/ripple_app/ripple_app_pt5.cpp \
-    ../../src/ripple_app/ripple_app_pt6.cpp \
-    ../../src/ripple_app/ripple_app_pt7.cpp \
-    ../../src/ripple_app/ripple_app_pt8.cpp \
-    ../../src/ripple_basics/ripple_basics.cpp \
-    ../../src/ripple_core/ripple_core.cpp \
-    ../../src/ripple_data/ripple_data.cpp \
-    ../../src/ripple_hyperleveldb/ripple_hyperleveldb.cpp \
-    ../../src/ripple_leveldb/ripple_leveldb.cpp \
-    ../../src/ripple_net/ripple_net.cpp \
-    ../../src/ripple_overlay/ripple_overlay.cpp \
-    ../../src/ripple_rpc/ripple_rpc.cpp \
-    ../../src/ripple_websocket/ripple_websocket.cpp
+    ../../src/ripple_app/ripple_app.unity.cpp \
+    ../../src/ripple_app/ripple_app_pt1.unity.cpp \
+    ../../src/ripple_app/ripple_app_pt2.unity.cpp \
+    ../../src/ripple_app/ripple_app_pt3.unity.cpp \
+    ../../src/ripple_app/ripple_app_pt4.unity.cpp \
+    ../../src/ripple_app/ripple_app_pt5.unity.cpp \
+    ../../src/ripple_app/ripple_app_pt6.unity.cpp \
+    ../../src/ripple_app/ripple_app_pt7.unity.cpp \
+    ../../src/ripple_app/ripple_app_pt8.unity.cpp \
+    ../../src/ripple_basics/ripple_basics.unity.cpp \
+    ../../src/ripple_core/ripple_core.unity.cpp \
+    ../../src/ripple_data/ripple_data.unity.cpp \
+    ../../src/ripple_hyperleveldb/ripple_hyperleveldb.unity.cpp \
+    ../../src/ripple_leveldb/ripple_leveldb.unity.cpp \
+    ../../src/ripple_net/ripple_net.unity.cpp \
+    ../../src/ripple_overlay/ripple_overlay.unity.cpp \
+    ../../src/ripple_rpc/ripple_rpc.unity.cpp \
+    ../../src/ripple_websocket/ripple_websocket.unity.cpp
 
 LIBS += \
     -lboost_date_time-mt\

Builds/VisualStudio2013/.gitattributes

@@ -0,0 +1,4 @@
+RippleD.vcxproj             -text
+RippleD.vcxproj.filters     -text
+
+

Builds/VisualStudio2013/RippleD.props

@@ -1,31 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <ImportGroup Label="PropertySheets" />
-  <PropertyGroup Label="UserMacros">
-    <RepoDir>..\..</RepoDir>
-  </PropertyGroup>
-  <PropertyGroup>
-    <OutDir>$(RepoDir)\build\VisualStudio2013\$(Configuration).$(Platform)\</OutDir>
-    <IntDir>$(RepoDir)\build\obj\VisualStudio2013\$(Configuration).$(Platform)\</IntDir>
-    <TargetName>rippled</TargetName>
-  </PropertyGroup>
-  <ItemDefinitionGroup>
-    <ClCompile>
-      <PreprocessorDefinitions>_VARIADIC_MAX=10;_WIN32_WINNT=0x0600;_SCL_SECURE_NO_WARNINGS;_CRT_SECURE_NO_WARNINGS;WIN32;%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <MultiProcessorCompilation>true</MultiProcessorCompilation>
-      <WarningLevel>Level3</WarningLevel>
-      <AdditionalIncludeDirectories>$(RepoDir)\src\protobuf\src;$(RepoDir)\src\protobuf\vsprojects;$(RepoDir)\src;$(RepoDir)\src\leveldb;$(RepoDir)\src\leveldb\include;$(RepoDir)\build\proto;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
-      <AdditionalOptions>/bigobj %(AdditionalOptions)</AdditionalOptions>
-      <ExceptionHandling>Async</ExceptionHandling>
-      <DisableSpecificWarnings>4018;4244</DisableSpecificWarnings>
-    </ClCompile>
-    <Link>
-      <AdditionalDependencies>Shlwapi.lib;%(AdditionalDependencies)</AdditionalDependencies>
-    </Link>
-  </ItemDefinitionGroup>
-  <ItemGroup>
-    <BuildMacro Include="RepoDir">
-      <Value>$(RepoDir)</Value>
-    </BuildMacro>
-  </ItemGroup>
-</Project>

Builds/VisualStudio2013/ripple.sln

@@ -1,11 +1,9 @@
 
 Microsoft Visual Studio Solution File, Format Version 12.00
-# Visual Studio 2013
+# Visual Studio Express 2013 for Windows Desktop
 VisualStudioVersion = 12.0.30110.0
 MinimumVisualStudioVersion = 10.0.40219.1
-Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "beast", "..\..\src\beast\Builds\VisualStudio2013\beast.vcxproj", "{73C5A0F0-7629-4DE7-9194-BE7AC6C19535}"
-EndProject
-Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "RippleD", "RippleD.vcxproj", "{B7F39ECD-473C-484D-BC34-31F8362506A5}"
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "RippleD", "RippleD.vcxproj", "{26B7D9AC-1A80-8EF8-6703-D061F1BECB75}"
 EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
@@ -15,22 +13,12 @@ Global
 		Release|x64 = Release|x64
 	EndGlobalSection
 	GlobalSection(ProjectConfigurationPlatforms) = postSolution
-		{73C5A0F0-7629-4DE7-9194-BE7AC6C19535}.Debug|Win32.ActiveCfg = Debug|Win32
-		{73C5A0F0-7629-4DE7-9194-BE7AC6C19535}.Debug|Win32.Build.0 = Debug|Win32
-		{73C5A0F0-7629-4DE7-9194-BE7AC6C19535}.Debug|x64.ActiveCfg = Debug|x64
-		{73C5A0F0-7629-4DE7-9194-BE7AC6C19535}.Debug|x64.Build.0 = Debug|x64
-		{73C5A0F0-7629-4DE7-9194-BE7AC6C19535}.Release|Win32.ActiveCfg = Release|Win32
-		{73C5A0F0-7629-4DE7-9194-BE7AC6C19535}.Release|Win32.Build.0 = Release|Win32
-		{73C5A0F0-7629-4DE7-9194-BE7AC6C19535}.Release|x64.ActiveCfg = Release|x64
-		{73C5A0F0-7629-4DE7-9194-BE7AC6C19535}.Release|x64.Build.0 = Release|x64
-		{B7F39ECD-473C-484D-BC34-31F8362506A5}.Debug|Win32.ActiveCfg = Debug|Win32
-		{B7F39ECD-473C-484D-BC34-31F8362506A5}.Debug|Win32.Build.0 = Debug|Win32
-		{B7F39ECD-473C-484D-BC34-31F8362506A5}.Debug|x64.ActiveCfg = Debug|x64
-		{B7F39ECD-473C-484D-BC34-31F8362506A5}.Debug|x64.Build.0 = Debug|x64
-		{B7F39ECD-473C-484D-BC34-31F8362506A5}.Release|Win32.ActiveCfg = Release|Win32
-		{B7F39ECD-473C-484D-BC34-31F8362506A5}.Release|Win32.Build.0 = Release|Win32
-		{B7F39ECD-473C-484D-BC34-31F8362506A5}.Release|x64.ActiveCfg = Release|x64
-		{B7F39ECD-473C-484D-BC34-31F8362506A5}.Release|x64.Build.0 = Release|x64
+		{26B7D9AC-1A80-8EF8-6703-D061F1BECB75}.Debug|Win32.ActiveCfg = debug|x64
+		{26B7D9AC-1A80-8EF8-6703-D061F1BECB75}.Debug|x64.ActiveCfg = debug|x64
+		{26B7D9AC-1A80-8EF8-6703-D061F1BECB75}.Debug|x64.Build.0 = debug|x64
+		{26B7D9AC-1A80-8EF8-6703-D061F1BECB75}.Release|Win32.ActiveCfg = release|x64
+		{26B7D9AC-1A80-8EF8-6703-D061F1BECB75}.Release|x64.ActiveCfg = release|x64
+		{26B7D9AC-1A80-8EF8-6703-D061F1BECB75}.Release|x64.Build.0 = release|x64
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE

Builds/rpm/rippled.spec

@@ -0,0 +1,53 @@
+Name:           rippled
+Version:        0.26.3-sp1
+Release:        1%{?dist}
+Summary:        Ripple peer-to-peer network daemon
+
+Group:          Applications/Internet
+License:        ISC
+URL:            https://github.com/ripple/rippled
+
+# curl -L -o SOURCES/rippled-release.zip https://github.com/ripple/rippled/archive/release.zip
+Source0:        rippled-release.zip
+BuildRoot:      %(mktemp -ud %{_tmppath}/%{name}-%{version}-%{release}-XXXXXX)
+
+BuildRequires:  gcc-c++ scons openssl-devel protobuf-devel
+Requires:       protobuf openssl
+
+
+%description
+Rippled is the server component of the Ripple network.
+
+
+%prep
+%setup -n rippled-release
+
+
+%build
+# Assume boost is manually installed
+export RIPPLED_BOOST_HOME=/usr/local/boost_1_55_0
+scons -j `grep -c processor /proc/cpuinfo` build/rippled
+
+
+%install
+rm -rf %{buildroot}
+mkdir -p %{buildroot}/usr/share/%{name}
+cp LICENSE %{buildroot}/usr/share/%{name}/
+mkdir -p %{buildroot}/usr/bin
+cp build/rippled %{buildroot}/usr/bin/rippled
+mkdir -p %{buildroot}/etc/%{name}
+cp doc/rippled-example.cfg %{buildroot}/etc/%{name}/rippled.cfg
+mkdir -p %{buildroot}/var/lib/%{name}/db
+mkdir -p %{buildroot}/var/log/%{name}
+
+
+%clean
+rm -rf %{buildroot}
+
+
+%files
+%defattr(-,root,root,-)
+/usr/bin/rippled
+/usr/share/rippled/LICENSE
+/etc/rippled/rippled-example.cfg
+

Builds/travis/clang.boost.patch

@@ -0,0 +1,13 @@
+--- /usr/include/boost/config/compiler/clang.hpp 2013-07-20 13:17:10.000000000 -0400
++++ /usr/include/boost/config/compiler/clang.rippled.hpp 2014-03-11 16:40:51.000000000 -0400
+@@ -39,6 +39,10 @@
+ // Clang supports "long long" in all compilation modes.
+ #define BOOST_HAS_LONG_LONG
+
++#if defined(__SIZEOF_INT128__)
++#  define BOOST_HAS_INT128
++#endif
++
+ //
+ // Dynamic shared object (DSO) and dynamic-link library (DLL) support
+ //

Builds/travis/static_error.boost.patch

@@ -0,0 +1,10 @@
+--- /usr/include/boost/bimap/detail/debug/static_error.hpp   2008-03-22 17:45:55.000000000 -0400
++++ /usr/include/boost/bimap/detail/debug/static_error.rippled.hpp   2014-03-12 19:40:05.000000000 -0400
+@@ -25,7 +25,6 @@
+ // a static error.
+ /*===========================================================================*/
+ #define BOOST_BIMAP_STATIC_ERROR(MESSAGE,VARIABLES)                           \
+-        struct BOOST_PP_CAT(BIMAP_STATIC_ERROR__,MESSAGE) {};                 \
+         BOOST_MPL_ASSERT_MSG(false,                                           \
+                              BOOST_PP_CAT(BIMAP_STATIC_ERROR__,MESSAGE),      \
+                              VARIABLES)

README.md

@@ -1,9 +1,8 @@
-#Ripple - P2P Payment Network
+#rippled - Ripple P2P server
 
 ##[![Build Status](https://travis-ci.org/ripple/rippled.png?branch=develop)](https://travis-ci.org/ripple/rippled)
-##[![Build Status](https://ci.ripple.com/jenkins/buildStatus/icon?job=rippled)](https://ci.ripple.com/jenkins/job/rippled/)
 
-This is the repository for Ripple's `rippled`, reference P2P network server.
+This is the repository for Ripple's `rippled`, reference P2P server.
 
 ###Build instructions:
 * https://ripple.com/wiki/Rippled_build_instructions
@@ -34,20 +33,8 @@ README for more details.
 Javascript / Mocha tests.
 
 ## License
-
-Provided under the terms of the ISC License:
-
-Permission to use, copy, modify, and/or distribute this software for any
-purpose  with  or without fee is hereby granted, provided that the above
-copyright notice and this permission notice appear in all copies.
-
-THE  SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
-WITH  REGARD  TO  THIS  SOFTWARE  INCLUDING  ALL  IMPLIED  WARRANTIES  OF
-MERCHANTABILITY  AND  FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
-ANY  SPECIAL ,  DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
-WHATSOEVER  RESULTING  FROM  LOSS  OF USE, DATA OR PROFITS, WHETHER IN AN
-ACTION  OF  CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
-OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+Ripple is open source and permissively licensed under the ISC license. See the
+LICENSE file for more details.
 
 ###For more information:
 * https://ripple.com

SConstruct

@@ -1,333 +1,634 @@
+# rippled SConstruct
 #
-# Ripple - SConstruct
-#
+'''
 
-import commands
-import copy
-import glob
+    Target          Builds
+    ----------------------------------------------------------------------------
+
+    <none>          Same as 'install'
+    install         Default target and copies it to build/rippled (default)
+
+    all             All available variants
+    debug           All available debug variants
+    release         All available release variants
+
+    clang           All clang variants
+    clang.debug     clang debug variant
+    clang.release   clang release variant
+
+    gcc             All gcc variants
+    gcc.debug       gcc debug variant
+    gcc.release     gcc release variant
+
+    msvc            All msvc variants
+    msvc.debug      MSVC debug variant
+    msvc.release    MSVC release variant
+
+    vcxproj         Generate Visual Studio 2013 project file
+
+If the clang toolchain is detected, then the default target will use it, else
+the gcc toolchain will be used. On Windows environments, the MSVC toolchain is
+also detected.
+
+'''
+#
+'''
+
+TODO
+
+- Fix git-describe support
+- Fix printing exemplar command lines
+- Fix toolchain detection
+
+
+'''
+#-------------------------------------------------------------------------------
+
+import collections
 import os
-import platform
-import re
+import subprocess
 import sys
+import textwrap
+import time
+import SCons.Action
 
-OSX = bool(platform.mac_ver()[0])
-FreeBSD = bool('FreeBSD' == platform.system())
-Linux   = bool('Linux' == platform.system())
-Ubuntu  = bool(Linux and 'Ubuntu' == platform.linux_distribution()[0])
-Debian  = bool(Linux and 'debian' == platform.linux_distribution()[0])
-Archlinux  = bool(Linux and ('','','') == platform.linux_distribution()) #Arch still has issues with the platform module
+sys.path.append(os.path.join('src', 'beast', 'site_scons'))
 
-USING_CLANG = OSX or os.environ.get('CC', None) == 'clang'
+import Beast
 
-#
-# We expect this to be set
-#
-BOOST_HOME = os.environ.get("RIPPLED_BOOST_HOME", None)
+#------------------------------------------------------------------------------
+
+def parse_time(t):
+    return time.strptime(t, '%a %b %d %H:%M:%S %Z %Y')
+
+CHECK_PLATFORMS = 'Debian', 'Ubuntu'
+CHECK_COMMAND = 'openssl version -a'
+CHECK_LINE = 'built on: '
+BUILD_TIME = 'Mon Apr  7 20:33:19 UTC 2014'
+OPENSSL_ERROR = ('Your openSSL was built on %s; '
+                 'rippled needs a version built on or after %s.')
+
+def check_openssl():
+    if Beast.system.platform in CHECK_PLATFORMS:
+        for line in subprocess.check_output(CHECK_COMMAND.split()).splitlines():
+            if line.startswith(CHECK_LINE):
+                line = line[len(CHECK_LINE):]
+                if parse_time(line) < parse_time(BUILD_TIME):
+                    raise Exception(OPENSSL_ERROR % (line, BUILD_TIME))
+                else:
+                    break
+        else:
+            raise Exception("Didn't find any '%s' line in '$ %s'" %
+                            (CHECK_LINE, CHECK_COMMAND))
 
 
-if OSX or Ubuntu or Debian or Archlinux:
-    CTAGS = 'ctags'
-elif FreeBSD:
-    CTAGS = 'exctags'
-else:
-    CTAGS = 'exuberant-ctags'
+def import_environ(env):
+    '''Imports environment settings into the construction environment'''
+    def set(keys):
+        if type(keys) == list:
+            for key in keys:
+                set(key)
+            return
+        if keys in os.environ:
+            value = os.environ[keys]
+            env[keys] = value
+    set(['GNU_CC', 'GNU_CXX', 'GNU_LINK'])
+    set(['CLANG_CC', 'CLANG_CXX', 'CLANG_LINK'])
 
-#
-# scons tools
-#
+def detect_toolchains(env):
+    def is_compiler(comp_from, comp_to):
+        return comp_from and comp_to in comp_from
 
-HONOR_ENVS = ['CC', 'CXX', 'PATH']
+    def detect_clang(env):
+        n = sum(x in env for x in ['CLANG_CC', 'CLANG_CXX', 'CLANG_LINK'])
+        if n > 0:
+            if n == 3:
+                return True
+            raise ValueError('CLANG_CC, CLANG_CXX, and CLANG_LINK must be set together')
+        cc = env.get('CC')
+        cxx = env.get('CXX')
+        link = env.subst(env.get('LINK'))
+        if (cc and cxx and link and
+            is_compiler(cc, 'clang') and
+            is_compiler(cxx, 'clang') and
+            is_compiler(link, 'clang')):
+            env['CLANG_CC'] = cc
+            env['CLANG_CXX'] = cxx
+            env['CLANG_LINK'] = link
+            return True
+        cc = env.WhereIs('clang')
+        cxx = env.WhereIs('clang++')
+        link = cxx
+        if (is_compiler(cc, 'clang') and
+            is_compiler(cxx, 'clang') and
+            is_compiler(link, 'clang')):
+           env['CLANG_CC'] = cc
+           env['CLANG_CXX'] = cxx
+           env['CLANG_LINK'] = link
+           return True
+        env['CLANG_CC'] = 'clang'
+        env['CLANG_CXX'] = 'clang++'
+        env['CLANG_LINK'] = env['LINK']
+        return False
 
-env = Environment(
-    tools = ['default', 'protoc'],
-    #ENV = dict((k, os.environ[k]) for k in HONOR_ENVS)
-    ENV = dict((k, os.environ[k]) for k in HONOR_ENVS if k in os.environ)
-)
+    def detect_gcc(env):
+        n = sum(x in env for x in ['GNU_CC', 'GNU_CXX', 'GNU_LINK'])
+        if n > 0:
+            if n == 3:
+                return True
+            raise ValueError('GNU_CC, GNU_CXX, and GNU_LINK must be set together')
+        cc = env.get('CC')
+        cxx = env.get('CXX')
+        link = env.subst(env.get('LINK'))
+        if (cc and cxx and link and
+            is_compiler(cc, 'gcc') and
+            is_compiler(cxx, 'g++') and
+            is_compiler(link, 'g++')):
+            env['GNU_CC'] = cc
+            env['GNU_CXX'] = cxx
+            env['GNU_LINK'] = link
+            return True
+        cc = env.WhereIs('gcc')
+        cxx = env.WhereIs('g++')
+        link = cxx
+        if (is_compiler(cc, 'gcc') and
+            is_compiler(cxx, 'g++') and
+            is_compiler(link, 'g++')):
+           env['GNU_CC'] = cc
+           env['GNU_CXX'] = cxx
+           env['GNU_LINK'] = link
+           return True
+        env['GNU_CC'] = 'gcc'
+        env['GNU_CXX'] = 'g++'
+        env['GNU_LINK'] = env['LINK']
+        return False
 
-# Use a newer gcc on FreeBSD
-if FreeBSD:
-    env.Replace(CC = 'gcc46')
-    env.Replace(CXX = 'g++46')
-    env.Append(CCFLAGS = ['-Wl,-rpath=/usr/local/lib/gcc46'])
-    env.Append(LINKFLAGS = ['-Wl,-rpath=/usr/local/lib/gcc46'])
+    toolchains = []
+    if detect_clang(env):
+        toolchains.append('clang')
+    if detect_gcc(env):
+        toolchains.append('gcc')
+    if env.Detect('cl'):
+        toolchains.append('msvc')
+    return toolchains
 
-if USING_CLANG:
-    env.Replace(CC= 'clang')
-    env.Replace(CXX= 'clang++')
+def files(base):
+    def _iter(base):
+        for parent, _, files in os.walk(base):
+            for path in files:
+                path = os.path.join(parent, path)
+                yield os.path.normpath(path)
+    return list(_iter(base))
 
-    if Linux:
-        env.Append(CXXFLAGS = ['-std=c++11', '-stdlib=libstdc++'])
-        env.Append(LINKFLAGS='-stdlib=libstdc++')
+def print_coms(target, source, env):
+    '''Display command line exemplars for an environment'''
+    print ('Target: ' + Beast.yellow(str(target[0])))
+    # TODO Add 'PROTOCCOM' to this list and make it work
+    Beast.print_coms(['CXXCOM', 'CCCOM', 'LINKCOM'], env)
 
-    if OSX:
-        env.Append(CXXFLAGS = ['-std=c++11', '-stdlib=libc++'])
-        env.Append(LINKFLAGS='-stdlib=libc++')
-        env['FRAMEWORKS'] = ['AppKit','Foundation']
+#-------------------------------------------------------------------------------
 
-GCC_VERSION = re.split('\.', commands.getoutput(env['CXX'] + ' -dumpversion'))
+# Set construction variables for the base environment
+def config_base(env):
+    if False:
+        env.Replace(
+            CCCOMSTR='Compiling ' + Beast.blue('$SOURCES'),
+            CXXCOMSTR='Compiling ' + Beast.blue('$SOURCES'),
+            LINKCOMSTR='Linking ' + Beast.blue('$TARGET'),
+            )
+    check_openssl()
 
-# Add support for ccache. Usage: scons ccache=1
-ccache = ARGUMENTS.get('ccache', 0)
-if int(ccache):
-    env.Prepend(CC = ['ccache'])
-    env.Prepend(CXX = ['ccache'])
-    ccache_dir = os.getenv('CCACHE_DIR')
-    if ccache_dir:
-        env.Replace(CCACHE_DIR = ccache_dir)
+    env.Append(CPPDEFINES=['OPENSSL_NO_SSL2'])
 
-#
-# Builder for CTags
-#
-ctags = Builder(action = '$CTAGS $CTAGSOPTIONS -f $TARGET $SOURCES')
-env.Append(BUILDERS = { 'CTags' : ctags })
-if OSX:
-    env.Replace(CTAGS = CTAGS)
-else:
-    env.Replace(CTAGS = CTAGS, CTAGSOPTIONS = '--tag-relative')
+    try:
+        BOOST_ROOT = os.path.normpath(os.environ['BOOST_ROOT'])
+        env.Append(CPPPATH=[
+            BOOST_ROOT,
+            ])
+        env.Append(LIBPATH=[
+            os.path.join(BOOST_ROOT, 'stage', 'lib'),
+            ])
+        env['BOOST_ROOT'] = BOOST_ROOT
+    except KeyError:
+        pass
 
-# Use openssl
-env.ParseConfig('pkg-config --static --cflags --libs openssl')
-# Use protobuf
-env.ParseConfig('pkg-config --static --cflags --libs protobuf')
+    if Beast.system.windows:
+        try:
+            OPENSSL_ROOT = os.path.normpath(os.environ['OPENSSL_ROOT'])
+            env.Append(CPPPATH=[
+                os.path.join(OPENSSL_ROOT, 'include'),
+                ])
+            env.Append(LIBPATH=[
+                os.path.join(OPENSSL_ROOT, 'lib', 'VC', 'static'),
+                ])
+        except KeyError:
+            pass
+    elif Beast.system.osx:
+        OSX_OPENSSL_ROOT = '/usr/local/Cellar/openssl/'
+        most_recent = sorted(os.listdir(OSX_OPENSSL_ROOT))[-1]
+        openssl = os.path.join(OSX_OPENSSL_ROOT, most_recent)
+        env.Prepend(CPPPATH='%s/include' % openssl)
+        env.Prepend(LIBPATH=['%s/lib' % openssl])
 
-# Beast uses kvm on FreeBSD
-if FreeBSD:
-    env.Append (
-        LIBS = [
-            'kvm'
+    # handle command-line arguments
+    profile_jemalloc = ARGUMENTS.get('profile-jemalloc')
+    if profile_jemalloc:
+        env.Append(CPPDEFINES={'PROFILE_JEMALLOC' : profile_jemalloc})
+        env.Append(LIBS=['jemalloc'])
+        env.Append(LIBPATH=[os.path.join(profile_jemalloc, 'lib')])
+        env.Append(CPPPATH=[os.path.join(profile_jemalloc, 'include')])
+        env.Append(LINKFLAGS=['-Wl,-rpath,' + os.path.join(profile_jemalloc, 'lib')])
+
+# Set toolchain and variant specific construction variables
+def config_env(toolchain, variant, env):
+    if variant == 'debug':
+        env.Append(CPPDEFINES=['DEBUG', '_DEBUG'])
+
+    elif variant == 'release':
+        env.Append(CPPDEFINES=['NDEBUG'])
+
+    if toolchain in Split('clang gcc'):
+        if Beast.system.linux:
+            env.ParseConfig('pkg-config --static --cflags --libs openssl')
+            env.ParseConfig('pkg-config --static --cflags --libs protobuf')
+
+        env.Prepend(CFLAGS=['-Wall'])
+        env.Prepend(CXXFLAGS=['-Wall'])
+
+        env.Append(CCFLAGS=[
+            '-Wno-sign-compare',
+            '-Wno-char-subscripts',
+            '-Wno-format',
+            ])
+
+        if toolchain == 'clang':
+            env.Append(CCFLAGS=['-Wno-redeclared-class-member'])
+
+        env.Append(CXXFLAGS=[
+            '-frtti',
+            '-std=c++11',
+            '-Wno-invalid-offsetof'])
+
+        if Beast.system.osx:
+            env.Append(CPPDEFINES={
+                'BEAST_COMPILE_OBJECTIVE_CPP': 1,
+                })
+
+        # These should be the same regardless of platform...
+        if Beast.system.osx:
+            env.Append(CCFLAGS=[
+                '-Wno-deprecated',
+                '-Wno-deprecated-declarations',
+                '-Wno-unused-variable',
+                '-Wno-unused-function',
+                ])
+        else:
+            if toolchain == 'gcc':
+                env.Append(CCFLAGS=[
+                    '-Wno-unused-but-set-variable'
+                    ])
+
+        boost_libs = [
+            'boost_date_time',
+            'boost_filesystem',
+            'boost_program_options',
+            'boost_regex',
+            'boost_system',
+            'boost_thread'
         ]
-    )
+        # We prefer static libraries for boost
+        if env.get('BOOST_ROOT'):
+            static_libs = ['%s/stage/lib/lib%s.a' % (env['BOOST_ROOT'], l) for
+                           l in boost_libs]
+            if all(os.path.exists(f) for f in static_libs):
+                boost_libs = [File(f) for f in static_libs]
 
-# The required version of boost is documented in the README file.
-BOOST_LIBS = [
-    'boost_date_time',
-    'boost_filesystem',
-    'boost_program_options',
-    'boost_regex',
-    'boost_system',
-    'boost_thread',
-]
+        env.Append(LIBS=boost_libs)
+        env.Append(LIBS=['dl'])
 
-# We whitelist platforms where the non -mt version is linked with pthreads. This
-# can be verified with: ldd libboost_filesystem.* If a threading library is
-# included the platform can be whitelisted.
-# if FreeBSD or Ubuntu or Archlinux:
+        if Beast.system.osx:
+            env.Append(LIBS=[
+                'crypto',
+                'protobuf',
+                'ssl',
+                ])
+            env.Append(FRAMEWORKS=[
+                'AppKit',
+                'Foundation'
+                ])
+        else:
+            env.Append(LIBS=['rt'])
 
-if not (USING_CLANG and Linux) and (FreeBSD or Ubuntu or Archlinux or OSX):
-    # non-mt libs do link with pthreads.
-    env.Append(
-        LIBS = BOOST_LIBS
-    )
-elif Linux and USING_CLANG and Ubuntu:
-    # It's likely going to be here if using boost 1.55 
-    boost_statics = [ ("/usr/lib/x86_64-linux-gnu/lib%s.a" % a) for a in 
-                      BOOST_LIBS ]
+        env.Append(LINKFLAGS=[
+            '-rdynamic'
+            ])
 
-    if not all(os.path.exists(f) for f in boost_statics):
-        # Else here
-        boost_statics = [("/usr/lib/lib%s.a" % a) for a in BOOST_LIBS]
-    
-    env.Append(LIBS = [File(f) for f in boost_statics])
-else:
-    env.Append(
-        LIBS = [l + '-mt' for l in BOOST_LIBS]
-    )
+        if variant == 'debug':
+            env.Append(CCFLAGS=[
+                '-g'
+                ])
+        elif variant == 'release':
+            env.Append(CCFLAGS=[
+                '-O3',
+                '-fno-strict-aliasing'
+                ])
 
-#-------------------------------------------------------------------------------
-#
-# VFALCO NOTE Clean area.
-#
-#-------------------------------------------------------------------------------
-#
-# Nothing having to do with directories, source files,
-# or include paths should reside outside the boundaries.
-#
+        if toolchain != 'msvc':
+            git = Beast.Git(env)
+            if git.exists:
+                id = '%s+%s.%s' % (git.tags, git.user, git.branch)
+                env.Append(CPPDEFINES={'GIT_COMMIT_ID' : '\'"%s"\'' % id })
 
-# List of includes passed to the C++ compiler.
-# These are all relative to the repo dir.
-#
-INCLUDE_PATHS = [
-    '.',
-    'src',
-    'src/leveldb',
-    'src/leveldb/port',
-    'src/leveldb/include',
-    'src/beast',
-    'build/proto'
-    ]
+        if toolchain == 'clang':
+            if Beast.system.osx:
+                env.Replace(CC='clang', CXX='clang++', LINK='clang++')
+            elif 'CLANG_CC' in env and 'CLANG_CXX' in env and 'CLANG_LINK' in env:
+                env.Replace(CC=env['CLANG_CC'],
+                            CXX=env['CLANG_CXX'],
+                            LINK=env['CLANG_LINK'])
+            # C and C++
+            # Add '-Wshorten-64-to-32'
+            env.Append(CCFLAGS=[])
+            # C++ only
+            env.Append(CXXFLAGS=[
+                '-Wno-mismatched-tags',
+                '-Wno-deprecated-register',
+                ])
 
-# if BOOST_HOME:
-#     INCLUDE_PATHS.append(BOOST_HOME)
+        elif toolchain == 'gcc':
+            if 'GNU_CC' in env and 'GNU_CXX' in env and 'GNU_LINK' in env:
+                env.Replace(CC=env['GNU_CC'],
+                            CXX=env['GNU_CXX'],
+                            LINK=env['GNU_LINK'])
+            # Why is this only for gcc?!
+            env.Append(CCFLAGS=['-Wno-unused-local-typedefs'])
 
-#-------------------------------------------------------------------------------
-#
-# Compiled sources
-#
+            # If we are in debug mode, use GCC-specific functionality to add
+            # extra error checking into the code (e.g. std::vector will throw
+            # for out-of-bounds conditions)
+            if variant == 'debug':
+                env.Append(CPPDEFINES={
+                    '_FORTIFY_SOURCE': 2
+                    })
 
-COMPILED_FILES = []
+    elif toolchain == 'msvc':
+        env.Append (CPPPATH=[
+            os.path.join('src', 'protobuf', 'src'),
+            os.path.join('src', 'protobuf', 'vsprojects'),
+            ])
+        env.Append(CCFLAGS=[
+            '/bigobj',              # Increase object file max size
+            '/EHa',                 # ExceptionHandling all
+            '/fp:precise',          # Floating point behavior
+            '/Gd',                  # __cdecl calling convention
+            '/Gm-',                 # Minimal rebuild: disabled
+            '/GR',                  # Enable RTTI
+            '/Gy-',                 # Function level linking: disabled
+            '/FS',
+            '/MP',                  # Multiprocessor compilation
+            '/openmp-',             # pragma omp: disabled
+            '/Zc:forScope',         # Language extension: for scope
+            '/Zi',                  # Generate complete debug info
+            '/errorReport:none',    # No error reporting to Internet
+            '/nologo',              # Suppress login banner
+            #'/Fd${TARGET}.pdb',     # Path: Program Database (.pdb)
+            '/W3',                  # Warning level 3
+            '/WX-',                 # Disable warnings as errors
+            '/wd"4018"',
+            '/wd"4244"',
+            '/wd"4267"',
+            '/wd"4800"',            # Disable C4800 (int to bool performance)
+            ])
+        env.Append(CPPDEFINES={
+            '_WIN32_WINNT' : '0x6000',
+            })
+        env.Append(CPPDEFINES=[
+            '_SCL_SECURE_NO_WARNINGS',
+            '_CRT_SECURE_NO_WARNINGS',
+            'WIN32_CONSOLE',
+            ])
+        env.Append(LIBS=[
+            'ssleay32MT.lib',
+            'libeay32MT.lib',
+            'Shlwapi.lib',
+            'kernel32.lib',
+            'user32.lib',
+            'gdi32.lib',
+            'winspool.lib',
+            'comdlg32.lib',
+            'advapi32.lib',
+            'shell32.lib',
+            'ole32.lib',
+            'oleaut32.lib',
+            'uuid.lib',
+            'odbc32.lib',
+            'odbccp32.lib',
+            ])
+        env.Append(LINKFLAGS=[
+            '/DEBUG',
+            '/DYNAMICBASE',
+            '/ERRORREPORT:NONE',
+            #'/INCREMENTAL',
+            '/MACHINE:X64',
+            '/MANIFEST',
+            #'''/MANIFESTUAC:"level='asInvoker' uiAccess='false'"''',
+            '/nologo',
+            '/NXCOMPAT',
+            '/SUBSYSTEM:CONSOLE',
+            '/TLBID:1',
+            ])
 
-# -------------------
-# Beast unity sources
-#
-if OSX:
-    # OSX: Use the Objective C++ version of beast_core
-    COMPILED_FILES.extend (['src/ripple/beast/ripple_beastobjc.mm'])
-else:
-    COMPILED_FILES.extend (['src/ripple/beast/ripple_beast.cpp'])
-COMPILED_FILES.extend (['src/ripple/beast/ripple_beastc.c'])
+        if variant == 'debug':
+            env.Append(CCFLAGS=[
+                '/GS',              # Buffers security check: enable
+                '/MTd',             # Language: Multi-threaded Debug CRT
+                '/Od',              # Optimization: Disabled
+                '/RTC1',            # Run-time error checks:
+                ])
+            env.Append(CPPDEFINES=[
+                '_CRTDBG_MAP_ALLOC'
+                ])
+        else:
+            env.Append(CCFLAGS=[
+                '/MT',              # Language: Multi-threaded CRT
+                '/Ox',              # Optimization: Full
+                ])
 
-# ------------------------------
-# New-style Ripple unity sources
-#
-COMPILED_FILES.extend([
-    'src/ripple/http/ripple_http.cpp',
-    'src/ripple/json/ripple_json.cpp',
-    'src/ripple/peerfinder/ripple_peerfinder.cpp',
-    'src/ripple/radmap/ripple_radmap.cpp',
-    'src/ripple/resource/ripple_resource.cpp',
-    'src/ripple/rocksdb/ripple_rocksdb.cpp',
-    'src/ripple/sitefiles/ripple_sitefiles.cpp',
-    'src/ripple/sslutil/ripple_sslutil.cpp',
-    'src/ripple/testoverlay/ripple_testoverlay.cpp',
-    'src/ripple/types/ripple_types.cpp',
-    'src/ripple/validators/ripple_validators.cpp',
-	'src/ripple/common/ripple_common.cpp',
-    ])
-
-# ------------------------------
-# Old-style Ripple unity sources
-#
-COMPILED_FILES.extend([
-    'src/ripple_app/ripple_app.cpp',
-    'src/ripple_app/ripple_app_pt1.cpp',
-    'src/ripple_app/ripple_app_pt2.cpp',
-    'src/ripple_app/ripple_app_pt3.cpp',
-    'src/ripple_app/ripple_app_pt4.cpp',
-    'src/ripple_app/ripple_app_pt5.cpp',
-    'src/ripple_app/ripple_app_pt6.cpp',
-    'src/ripple_app/ripple_app_pt7.cpp',
-    'src/ripple_app/ripple_app_pt8.cpp',
-    'src/ripple_basics/ripple_basics.cpp',
-    'src/ripple_core/ripple_core.cpp',
-    'src/ripple_data/ripple_data.cpp',
-    'src/ripple_hyperleveldb/ripple_hyperleveldb.cpp',
-    'src/ripple_leveldb/ripple_leveldb.cpp',
-    'src/ripple_net/ripple_net.cpp',
-    'src/ripple_overlay/ripple_overlay.cpp',
-    'src/ripple_rpc/ripple_rpc.cpp',
-    'src/ripple_websocket/ripple_websocket.cpp'
-    ])
-
-#
-#
-#-------------------------------------------------------------------------------
-
-# Map top level source directories to their location in the outputs
-#
-
-VariantDir('build/obj/src', 'src', duplicate=0)
-
-#-------------------------------------------------------------------------------
-
-# Add the list of includes to compiler include paths.
-#
-for path in INCLUDE_PATHS:
-    env.Append (CPPPATH = [ path ])
-
-if BOOST_HOME:
-    env.Prepend (CPPPATH = [ BOOST_HOME ])
-
-#-------------------------------------------------------------------------------
-
-# Apparently, only linux uses -ldl
-if Linux: # not FreeBSD:
-    env.Append(
-        LIBS = [
-            'dl', # dynamic linking for linux
-        ]
-    )
-
-env.Append(
-    LIBS = \
-        # rt is for clock_nanosleep in beast
-        ['rt'] if not OSX else [] +\
-        [
-            'z'
-        ]
-)
-
-# We prepend, in case there's another BOOST somewhere on the path
-# such, as installed into `/usr/lib/`
-if BOOST_HOME is not None:
-    env.Prepend(
-        LIBPATH = ["%s/stage/lib" % BOOST_HOME])
-
-if not OSX:
-    env.Append(LINKFLAGS = [
-        '-rdynamic',
-        '-pthread',
-        ])
-
-DEBUGFLAGS  = ['-g', '-DDEBUG', '-D_DEBUG']
-
-env.Append(CCFLAGS = ['-pthread', '-Wall', '-Wno-sign-compare', '-Wno-char-subscripts']+DEBUGFLAGS)
-if not USING_CLANG:
-     more_warnings = ['-Wno-unused-local-typedefs']
-else:
-     # This disables the "You said it was a struct AND a class, wth is going on
-     # warnings"
-     more_warnings = ['-Wno-mismatched-tags']
-     # This needs to be a CCFLAGS not a CXXFLAGS
-     env.Append(CCFLAGS = more_warnings)
-
-env.Append(CXXFLAGS = ['-O1','-pthread', '-Wno-invalid-offsetof', '-Wformat']+more_warnings+DEBUGFLAGS)
-
-# RTTI is required for Beast and CountedObject.
-#
-env.Append(CXXFLAGS = ['-frtti'])
-
-UBUNTU_GCC_48_INSTALL_STEPS = '''
-https://ripple.com/wiki/Ubuntu_build_instructions#Ubuntu_versions_older_than_13.10_:_Install_gcc_4.8'''
-
-if not USING_CLANG:
-    if (int(GCC_VERSION[0]) == 4 and int(GCC_VERSION[1]) < 7):
-        print "\nrippled, using c++11, requires g++ version >= 4.8 to compile"
-
-        if Ubuntu:
-          print UBUNTU_GCC_48_INSTALL_STEPS
-
-        sys.exit(1)
     else:
-        env.Append(CXXFLAGS = ['-std=c++11'])
+        raise SCons.UserError('Unknown toolchain == "%s"' % toolchain)
 
-# FreeBSD doesn't support O_DSYNC
-if FreeBSD:
-    env.Append(CPPFLAGS = ['-DMDB_DSYNC=O_SYNC'])
+#-------------------------------------------------------------------------------
 
-if OSX:
-    env.Append(LINKFLAGS = ['-L/usr/local/opt/openssl/lib'])
-    env.Append(CXXFLAGS = ['-I/usr/local/opt/openssl/include'])
+def addSource(path, env, variant_dirs, CPPPATH=[]):
+    if CPPPATH:
+        env = env.Clone()
+        env.Prepend(CPPPATH=CPPPATH)
+    return env.Object(Beast.variantFile(path, variant_dirs))
 
-PROTO_SRCS = env.Protoc([], 'src/ripple_data/protocol/ripple.proto', PROTOCOUTDIR='build/proto', PROTOCPYTHONOUTDIR=None)
-env.Clean(PROTO_SRCS, 'site_scons/site_tools/protoc.pyc')
+#-------------------------------------------------------------------------------
 
-# Only tag actual Ripple files.
-TAG_SRCS    = copy.copy(COMPILED_FILES)
+# Configure the base construction environment
+root_dir = Dir('#').srcnode().get_abspath() # Path to this SConstruct file
+build_dir = os.path.join('build')
+base = Environment(
+    toolpath=[os.path.join ('src', 'beast', 'site_scons', 'site_tools')],
+    tools=['default', 'Protoc', 'VSProject'],
+    ENV=os.environ,
+    TARGET_ARCH='x86_64')
+import_environ(base)
+config_base(base)
+base.Append(CPPPATH=[
+    'src',
+    os.path.join('src', 'beast'),
+    os.path.join(build_dir, 'proto'),
+    ])
 
-# Derive the object files from the source files.
-OBJECT_FILES = []
+# Configure the toolchains, variants, default toolchain, and default target
+variants = ['debug', 'release']
+all_toolchains = ['clang', 'gcc', 'msvc']
+if Beast.system.osx:
+    toolchains = ['clang']
+    default_toolchain = 'clang'
+else:
+    toolchains = detect_toolchains(base)
+    if not toolchains:
+        raise ValueError('No toolchains detected!')
+    if 'msvc' in toolchains:
+        default_toolchain = 'msvc'
+    elif 'gcc' in toolchains:
+        if 'clang' in toolchains:
+            cxx = os.environ.get('CXX', 'g++')
+            default_toolchain = 'clang' if 'clang' in cxx else 'gcc'
+        else:
+            default_toolchain = 'gcc'
+    elif 'clang' in toolchains:
+        default_toolchain = 'clang'
+    else:
+        raise ValueError("Don't understand toolchains in " + str(toolchains))
+default_variant = 'debug'
+default_target = None
 
-OBJECT_FILES.append(PROTO_SRCS[0])
+for source in [
+    'src/ripple/proto/ripple.proto',
+    ]:
+    base.Protoc([],
+        source,
+        PROTOCPROTOPATH=[os.path.dirname(source)],
+        PROTOCOUTDIR=os.path.join(build_dir, 'proto'),
+        PROTOCPYTHONOUTDIR=None)
 
-for file in COMPILED_FILES:
-    OBJECT_FILES.append('build/obj/' + file)
+# Declare the targets
+aliases = collections.defaultdict(list)
+msvc_configs = []
+for toolchain in all_toolchains:
+    for variant in variants:
+        # Configure this variant's construction environment
+        env = base.Clone()
+        config_env(toolchain, variant, env)
+        variant_name = '%s.%s' % (toolchain, variant)
+        variant_dir = os.path.join(build_dir, variant_name)
+        variant_dirs = {
+            os.path.join(variant_dir, 'src') :
+                'src',
+            os.path.join(variant_dir, 'proto') :
+                os.path.join (build_dir, 'proto'),
+            }
+        for dest, source in variant_dirs.iteritems():
+            env.VariantDir(dest, source, duplicate=0)
+        objects = []
+        objects.append(addSource('src/ripple/unity/app.cpp', env, variant_dirs))
+        objects.append(addSource('src/ripple/unity/app1.cpp', env, variant_dirs))
+        objects.append(addSource('src/ripple/unity/app2.cpp', env, variant_dirs))
+        objects.append(addSource('src/ripple/unity/app3.cpp', env, variant_dirs))
+        objects.append(addSource('src/ripple/unity/app4.cpp', env, variant_dirs))
+        objects.append(addSource('src/ripple/unity/app5.cpp', env, variant_dirs))
+        objects.append(addSource('src/ripple/unity/app6.cpp', env, variant_dirs))
+        objects.append(addSource('src/ripple/unity/app7.cpp', env, variant_dirs))
+        objects.append(addSource('src/ripple/unity/app8.cpp', env, variant_dirs))
+        objects.append(addSource('src/ripple/unity/app9.cpp', env, variant_dirs))
+        objects.append(addSource('src/ripple/unity/basics.cpp', env, variant_dirs))
+        objects.append(addSource('src/ripple/unity/beast.cpp', env, variant_dirs))
+        objects.append(addSource('src/ripple/unity/beastc.c', env, variant_dirs))
+        objects.append(addSource('src/ripple/unity/common.cpp', env, variant_dirs))
+        objects.append(addSource('src/ripple/unity/core.cpp', env, variant_dirs))
+        objects.append(addSource('src/ripple/unity/data.cpp', env, variant_dirs))
+        objects.append(addSource('src/ripple/unity/http.cpp', env, variant_dirs))
+        objects.append(addSource('src/ripple/unity/json.cpp', env, variant_dirs))
+        objects.append(addSource('src/ripple/unity/net.cpp', env, variant_dirs))
+        objects.append(addSource('src/ripple/unity/overlay.cpp', env, variant_dirs))
+        objects.append(addSource('src/ripple/unity/peerfinder.cpp', env, variant_dirs))
+        objects.append(addSource('src/ripple/unity/protobuf.cpp', env, variant_dirs))
+        objects.append(addSource('src/ripple/unity/ripple.proto.cpp', env, variant_dirs))
+        objects.append(addSource('src/ripple/unity/radmap.cpp', env, variant_dirs))
+        objects.append(addSource('src/ripple/unity/resource.cpp', env, variant_dirs))
+        objects.append(addSource('src/ripple/unity/rpcx.cpp', env, variant_dirs))
+        objects.append(addSource('src/ripple/unity/sitefiles.cpp', env, variant_dirs))
+        objects.append(addSource('src/ripple/unity/sslutil.cpp', env, variant_dirs))
+        objects.append(addSource('src/ripple/unity/testoverlay.cpp', env, variant_dirs))
+        objects.append(addSource('src/ripple/unity/types.cpp', env, variant_dirs))
+        objects.append(addSource('src/ripple/unity/validators.cpp', env, variant_dirs))
+        objects.append(addSource('src/ripple/unity/websocket.cpp', env, variant_dirs))
 
-#
-# Targets
-#
+        objects.append(addSource('src/ripple/unity/nodestore.cpp', env, variant_dirs, [
+            'src/leveldb/include',
+            #'src/hyperleveldb/include', # hyper
+            'src/rocksdb2/include',
+            ]))
 
-rippled = env.Program('build/rippled', OBJECT_FILES)
+        objects.append(addSource('src/ripple/unity/leveldb.cpp', env, variant_dirs, [
+            'src/leveldb/',
+            'src/leveldb/include',
+            'src/snappy/snappy',
+            'src/snappy/config',
+            ]))
 
-tags    = env.CTags('tags', TAG_SRCS)
+        objects.append(addSource('src/ripple/unity/hyperleveldb.cpp', env, variant_dirs, [
+            'src/hyperleveldb',
+            'src/snappy/snappy',
+            'src/snappy/config',
+            ]))
 
-Default(rippled, tags)
+        objects.append(addSource('src/ripple/unity/rocksdb.cpp', env, variant_dirs, [
+            'src/rocksdb2',
+            'src/rocksdb2/include',
+            'src/snappy/snappy',
+            'src/snappy/config',
+            ]))
+
+        objects.append(addSource('src/ripple/unity/snappy.cpp', env, variant_dirs, [
+            'src/snappy/snappy',
+            'src/snappy/config',
+            ]))
+
+        if toolchain == "clang" and Beast.system.osx:
+            objects.append(addSource('src/ripple/unity/beastobjc.mm', env, variant_dirs))
+
+        target = env.Program(
+            target = os.path.join(variant_dir, 'rippled'),
+            source = objects
+            )
+
+        if toolchain == default_toolchain and variant == default_variant:
+            default_target = target
+            install_target = env.Install (build_dir, source = default_target)
+            env.Alias ('install', install_target)
+            env.Default (install_target)
+            aliases['all'].extend(install_target)
+        if toolchain == 'msvc':
+            config = env.VSProjectConfig(variant, 'x64', target, env)
+            msvc_configs.append(config)
+        if toolchain in toolchains:
+            aliases['all'].extend(target)
+            aliases[variant].extend(target)
+            aliases[toolchain].extend(target)
+            env.Alias(variant_name, target)
+
+for key, value in aliases.iteritems():
+    env.Alias(key, value)
+
+vcxproj = base.VSProject(
+    os.path.join('Builds', 'VisualStudio2013', 'RippleD'),
+    source = [],
+    VSPROJECT_ROOT_DIRS = ['src/beast', 'src', '.'],
+    VSPROJECT_CONFIGS = msvc_configs)
+base.Alias('vcxproj', vcxproj)

bin/LT

@@ -0,0 +1 @@
+LedgerTool.py

bin/LedgerTool.py

@@ -0,0 +1,24 @@
+#!/usr/bin/env python
+
+from __future__ import absolute_import, division, print_function, unicode_literals
+
+import sys
+import traceback
+
+from ripple.ledger import Server
+from ripple.ledger.commands import Cache, Info, Print
+from ripple.ledger.Args import ARGS
+from ripple.util import Log
+from ripple.util.CommandList import CommandList
+
+_COMMANDS = CommandList(Cache, Info, Print)
+
+if __name__ == '__main__':
+    try:
+        server = Server.Server()
+        args = list(ARGS.command)
+        _COMMANDS.run_safe(args.pop(0), server, *args)
+    except Exception as e:
+        if ARGS.verbose:
+            print(traceback.format_exc(), sys.stderr)
+        Log.error(e)

bin/README.md

@@ -0,0 +1,8 @@
+Unit Tests
+==========
+
+To run the Python unit tests, execute:
+
+     python -m unittest discover
+
+from this directory.

bin/decorator.py

@@ -0,0 +1,251 @@
+##########################     LICENCE     ###############################
+
+# Copyright (c) 2005-2012, Michele Simionato
+# All rights reserved.
+
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are
+# met:
+
+#   Redistributions of source code must retain the above copyright 
+#   notice, this list of conditions and the following disclaimer.
+#   Redistributions in bytecode 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. 
+
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS 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 COPYRIGHT
+# HOLDERS 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.
+
+"""
+Decorator module, see http://pypi.python.org/pypi/decorator
+for the documentation.
+"""
+
+__version__ = '3.4.0'
+
+__all__ = ["decorator", "FunctionMaker", "contextmanager"]
+
+import sys, re, inspect
+if sys.version >= '3':
+    from inspect import getfullargspec
+    def get_init(cls):
+        return cls.__init__
+else:
+    class getfullargspec(object):
+        "A quick and dirty replacement for getfullargspec for Python 2.X"
+        def __init__(self, f):
+            self.args, self.varargs, self.varkw, self.defaults = \
+                inspect.getargspec(f)
+            self.kwonlyargs = []
+            self.kwonlydefaults = None
+        def __iter__(self):
+            yield self.args
+            yield self.varargs
+            yield self.varkw
+            yield self.defaults
+    def get_init(cls):
+        return cls.__init__.im_func
+
+DEF = re.compile('\s*def\s*([_\w][_\w\d]*)\s*\(')
+
+# basic functionality
+class FunctionMaker(object):
+    """
+    An object with the ability to create functions with a given signature.
+    It has attributes name, doc, module, signature, defaults, dict and
+    methods update and make.
+    """
+    def __init__(self, func=None, name=None, signature=None,
+                 defaults=None, doc=None, module=None, funcdict=None):
+        self.shortsignature = signature
+        if func:
+            # func can be a class or a callable, but not an instance method
+            self.name = func.__name__
+            if self.name == '<lambda>': # small hack for lambda functions
+                self.name = '_lambda_' 
+            self.doc = func.__doc__
+            self.module = func.__module__
+            if inspect.isfunction(func):
+                argspec = getfullargspec(func)
+                self.annotations = getattr(func, '__annotations__', {})
+                for a in ('args', 'varargs', 'varkw', 'defaults', 'kwonlyargs',
+                          'kwonlydefaults'):
+                    setattr(self, a, getattr(argspec, a))
+                for i, arg in enumerate(self.args):
+                    setattr(self, 'arg%d' % i, arg)
+                if sys.version < '3': # easy way
+                    self.shortsignature = self.signature = \
+                        inspect.formatargspec(
+                        formatvalue=lambda val: "", *argspec)[1:-1]
+                else: # Python 3 way
+                    allargs = list(self.args)
+                    allshortargs = list(self.args)
+                    if self.varargs:
+                        allargs.append('*' + self.varargs)
+                        allshortargs.append('*' + self.varargs)
+                    elif self.kwonlyargs:
+                        allargs.append('*') # single star syntax
+                    for a in self.kwonlyargs:
+                        allargs.append('%s=None' % a)
+                        allshortargs.append('%s=%s' % (a, a))
+                    if self.varkw:
+                        allargs.append('**' + self.varkw)
+                        allshortargs.append('**' + self.varkw)
+                    self.signature = ', '.join(allargs)
+                    self.shortsignature = ', '.join(allshortargs)
+                self.dict = func.__dict__.copy()
+        # func=None happens when decorating a caller
+        if name:
+            self.name = name
+        if signature is not None:
+            self.signature = signature
+        if defaults:
+            self.defaults = defaults
+        if doc:
+            self.doc = doc
+        if module:
+            self.module = module
+        if funcdict:
+            self.dict = funcdict
+        # check existence required attributes
+        assert hasattr(self, 'name')
+        if not hasattr(self, 'signature'):
+            raise TypeError('You are decorating a non function: %s' % func)
+
+    def update(self, func, **kw):
+        "Update the signature of func with the data in self"
+        func.__name__ = self.name
+        func.__doc__ = getattr(self, 'doc', None)
+        func.__dict__ = getattr(self, 'dict', {})
+        func.func_defaults = getattr(self, 'defaults', ())
+        func.__kwdefaults__ = getattr(self, 'kwonlydefaults', None)
+        func.__annotations__ = getattr(self, 'annotations', None)
+        callermodule = sys._getframe(3).f_globals.get('__name__', '?')
+        func.__module__ = getattr(self, 'module', callermodule)
+        func.__dict__.update(kw)
+
+    def make(self, src_templ, evaldict=None, addsource=False, **attrs):
+        "Make a new function from a given template and update the signature"
+        src = src_templ % vars(self) # expand name and signature
+        evaldict = evaldict or {}
+        mo = DEF.match(src)
+        if mo is None:
+            raise SyntaxError('not a valid function template\n%s' % src)
+        name = mo.group(1) # extract the function name
+        names = set([name] + [arg.strip(' *') for arg in 
+                             self.shortsignature.split(',')])
+        for n in names:
+            if n in ('_func_', '_call_'):
+                raise NameError('%s is overridden in\n%s' % (n, src))
+        if not src.endswith('\n'): # add a newline just for safety
+            src += '\n' # this is needed in old versions of Python
+        try:
+            code = compile(src, '<string>', 'single')
+            # print >> sys.stderr, 'Compiling %s' % src
+            exec code in evaldict
+        except:
+            print >> sys.stderr, 'Error in generated code:'
+            print >> sys.stderr, src
+            raise
+        func = evaldict[name]
+        if addsource:
+            attrs['__source__'] = src
+        self.update(func, **attrs)
+        return func
+
+    @classmethod
+    def create(cls, obj, body, evaldict, defaults=None,
+               doc=None, module=None, addsource=True, **attrs):
+        """
+        Create a function from the strings name, signature and body.
+        evaldict is the evaluation dictionary. If addsource is true an attribute
+        __source__ is added to the result. The attributes attrs are added,
+        if any.
+        """
+        if isinstance(obj, str): # "name(signature)"
+            name, rest = obj.strip().split('(', 1)
+            signature = rest[:-1] #strip a right parens            
+            func = None
+        else: # a function
+            name = None
+            signature = None
+            func = obj
+        self = cls(func, name, signature, defaults, doc, module)
+        ibody = '\n'.join('    ' + line for line in body.splitlines())
+        return self.make('def %(name)s(%(signature)s):\n' + ibody, 
+                        evaldict, addsource, **attrs)
+  
+def decorator(caller, func=None):
+    """
+    decorator(caller) converts a caller function into a decorator;
+    decorator(caller, func) decorates a function using a caller.
+    """
+    if func is not None: # returns a decorated function
+        evaldict = func.func_globals.copy()
+        evaldict['_call_'] = caller
+        evaldict['_func_'] = func
+        return FunctionMaker.create(
+            func, "return _call_(_func_, %(shortsignature)s)",
+            evaldict, undecorated=func, __wrapped__=func)
+    else: # returns a decorator
+        if inspect.isclass(caller):
+            name = caller.__name__.lower()
+            callerfunc = get_init(caller)
+            doc = 'decorator(%s) converts functions/generators into ' \
+                'factories of %s objects' % (caller.__name__, caller.__name__)
+            fun = getfullargspec(callerfunc).args[1] # second arg
+        elif inspect.isfunction(caller):
+            name = '_lambda_' if caller.__name__ == '<lambda>' \
+                else caller.__name__
+            callerfunc = caller
+            doc = caller.__doc__
+            fun = getfullargspec(callerfunc).args[0] # first arg
+        else: # assume caller is an object with a __call__ method
+            name = caller.__class__.__name__.lower()
+            callerfunc = caller.__call__.im_func
+            doc = caller.__call__.__doc__
+            fun = getfullargspec(callerfunc).args[1] # second arg
+        evaldict = callerfunc.func_globals.copy()
+        evaldict['_call_'] = caller
+        evaldict['decorator'] = decorator
+        return FunctionMaker.create(
+            '%s(%s)' % (name, fun), 
+            'return decorator(_call_, %s)' % fun,
+            evaldict, undecorated=caller, __wrapped__=caller,
+            doc=doc, module=caller.__module__)
+
+######################### contextmanager ########################
+
+def __call__(self, func):
+    'Context manager decorator'
+    return FunctionMaker.create(
+        func, "with _self_: return _func_(%(shortsignature)s)",
+        dict(_self_=self, _func_=func), __wrapped__=func)
+
+try: # Python >= 3.2
+
+    from contextlib import _GeneratorContextManager 
+    ContextManager = type(
+        'ContextManager', (_GeneratorContextManager,), dict(__call__=__call__))
+
+except ImportError: # Python >= 2.5
+
+    from contextlib import GeneratorContextManager
+    def __init__(self, f, *a, **k):
+        return GeneratorContextManager.__init__(self, f(*a, **k))
+    ContextManager = type(
+        'ContextManager', (GeneratorContextManager,), 
+        dict(__call__=__call__, __init__=__init__))
+    
+contextmanager = decorator(ContextManager)

bin/jsonpath_rw/__init__.py

@@ -0,0 +1,4 @@
+from .jsonpath import *
+from .parser import parse
+
+__version__ = '1.3.0'

bin/jsonpath_rw/jsonpath.py

@@ -0,0 +1,510 @@
+from __future__ import unicode_literals, print_function, absolute_import, division, generators, nested_scopes
+import logging
+import six
+from six.moves import xrange
+from itertools import *
+
+logger = logging.getLogger(__name__)
+
+# Turn on/off the automatic creation of id attributes
+# ... could be a kwarg pervasively but uses are rare and simple today
+auto_id_field = None
+
+class JSONPath(object):
+    """
+    The base class for JSONPath abstract syntax; those
+    methods stubbed here are the interface to supported 
+    JSONPath semantics.
+    """
+
+    def find(self, data):
+        """
+        All `JSONPath` types support `find()`, which returns an iterable of `DatumInContext`s.
+        They keep track of the path followed to the current location, so if the calling code
+        has some opinion about that, it can be passed in here as a starting point.
+        """
+        raise NotImplementedError()
+
+    def update(self, data, val):
+        "Returns `data` with the specified path replaced by `val`"
+        raise NotImplementedError()
+
+    def child(self, child):
+        """
+        Equivalent to Child(self, next) but with some canonicalization
+        """
+        if isinstance(self, This) or isinstance(self, Root):
+            return child
+        elif isinstance(child, This):
+            return self
+        elif isinstance(child, Root):
+            return child
+        else:
+            return Child(self, child)
+
+    def make_datum(self, value):
+        if isinstance(value, DatumInContext):
+            return value
+        else:
+            return DatumInContext(value, path=Root(), context=None)
+
+class DatumInContext(object):
+    """
+    Represents a datum along a path from a context.
+
+    Essentially a zipper but with a structure represented by JsonPath, 
+    and where the context is more of a parent pointer than a proper 
+    representation of the context.
+
+    For quick-and-dirty work, this proxies any non-special attributes
+    to the underlying datum, but the actual datum can (and usually should)
+    be retrieved via the `value` attribute.
+
+    To place `datum` within another, use `datum.in_context(context=..., path=...)`
+    which extends the path. If the datum already has a context, it places the entire
+    context within that passed in, so an object can be built from the inside
+    out.
+    """
+    @classmethod
+    def wrap(cls, data):
+        if isinstance(data, cls):
+            return data
+        else:
+            return cls(data)
+
+    def __init__(self, value, path=None, context=None):
+        self.value = value
+        self.path = path or This()
+        self.context = None if context is None else DatumInContext.wrap(context)
+
+    def in_context(self, context, path):
+        context = DatumInContext.wrap(context)
+
+        if self.context:
+            return DatumInContext(value=self.value, path=self.path, context=context.in_context(path=path, context=context))
+        else:
+            return DatumInContext(value=self.value, path=path, context=context)
+
+    @property
+    def full_path(self):
+        return self.path if self.context is None else self.context.full_path.child(self.path)
+
+    @property
+    def id_pseudopath(self):
+        """
+        Looks like a path, but with ids stuck in when available
+        """
+        try:
+            pseudopath = Fields(str(self.value[auto_id_field]))
+        except (TypeError, AttributeError, KeyError): # This may not be all the interesting exceptions
+            pseudopath = self.path
+
+        if self.context:
+            return self.context.id_pseudopath.child(pseudopath)
+        else:
+            return pseudopath
+
+    def __repr__(self):
+        return '%s(value=%r, path=%r, context=%r)' % (self.__class__.__name__, self.value, self.path, self.context)
+
+    def __eq__(self, other):
+        return isinstance(other, DatumInContext) and other.value == self.value and other.path == self.path and self.context == other.context
+
+class AutoIdForDatum(DatumInContext):
+    """
+    This behaves like a DatumInContext, but the value is
+    always the path leading up to it, not including the "id",
+    and with any "id" fields along the way replacing the prior 
+    segment of the path
+
+    For example, it will make "foo.bar.id" return a datum
+    that behaves like DatumInContext(value="foo.bar", path="foo.bar.id").
+
+    This is disabled by default; it can be turned on by
+    settings the `auto_id_field` global to a value other
+    than `None`. 
+    """
+    
+    def __init__(self, datum, id_field=None):
+        """
+        Invariant is that datum.path is the path from context to datum. The auto id
+        will either be the id in the datum (if present) or the id of the context
+        followed by the path to the datum.
+
+        The path to this datum is always the path to the context, the path to the
+        datum, and then the auto id field.
+        """
+        self.datum = datum
+        self.id_field = id_field or auto_id_field
+
+    @property
+    def value(self):
+        return str(self.datum.id_pseudopath)
+
+    @property
+    def path(self):
+        return self.id_field
+
+    @property
+    def context(self):
+        return self.datum
+
+    def __repr__(self):
+        return '%s(%r)' % (self.__class__.__name__, self.datum)
+
+    def in_context(self, context, path):
+        return AutoIdForDatum(self.datum.in_context(context=context, path=path))
+
+    def __eq__(self, other):
+        return isinstance(other, AutoIdForDatum) and other.datum == self.datum and self.id_field == other.id_field
+
+
+class Root(JSONPath):
+    """
+    The JSONPath referring to the "root" object. Concrete syntax is '$'.
+    The root is the topmost datum without any context attached.
+    """
+
+    def find(self, data):
+        if not isinstance(data, DatumInContext):
+            return [DatumInContext(data, path=Root(), context=None)]
+        else:
+            if data.context is None:
+                return [DatumInContext(data.value, context=None, path=Root())]
+            else:
+                return Root().find(data.context)
+
+    def update(self, data, val):
+        return val
+
+    def __str__(self):
+        return '$'
+
+    def __repr__(self):
+        return 'Root()'
+
+    def __eq__(self, other):
+        return isinstance(other, Root)
+
+class This(JSONPath):
+    """
+    The JSONPath referring to the current datum. Concrete syntax is '@'.
+    """
+
+    def find(self, datum):
+        return [DatumInContext.wrap(datum)]
+
+    def update(self, data, val):
+        return val
+
+    def __str__(self):
+        return '`this`'
+
+    def __repr__(self):
+        return 'This()'
+
+    def __eq__(self, other):
+        return isinstance(other, This)
+
+class Child(JSONPath):
+    """
+    JSONPath that first matches the left, then the right.
+    Concrete syntax is <left> '.' <right>
+    """
+    
+    def __init__(self, left, right):
+        self.left = left
+        self.right = right
+
+    def find(self, datum):
+        """
+        Extra special case: auto ids do not have children,
+        so cut it off right now rather than auto id the auto id
+        """
+        
+        return [submatch
+                for subdata in self.left.find(datum)
+                if not isinstance(subdata, AutoIdForDatum)
+                for submatch in self.right.find(subdata)]
+
+    def __eq__(self, other):
+        return isinstance(other, Child) and self.left == other.left and self.right == other.right
+
+    def __str__(self):
+        return '%s.%s' % (self.left, self.right)
+
+    def __repr__(self):
+        return '%s(%r, %r)' % (self.__class__.__name__, self.left, self.right)
+
+class Parent(JSONPath):
+    """
+    JSONPath that matches the parent node of the current match.
+    Will crash if no such parent exists.
+    Available via named operator `parent`.
+    """
+
+    def find(self, datum):
+        datum = DatumInContext.wrap(datum)
+        return [datum.context]
+
+    def __eq__(self, other):
+        return isinstance(other, Parent)
+
+    def __str__(self):
+        return '`parent`'
+
+    def __repr__(self):
+        return 'Parent()'
+        
+
+class Where(JSONPath):
+    """
+    JSONPath that first matches the left, and then
+    filters for only those nodes that have
+    a match on the right.
+
+    WARNING: Subject to change. May want to have "contains"
+    or some other better word for it.
+    """
+    
+    def __init__(self, left, right):
+        self.left = left
+        self.right = right
+
+    def find(self, data):
+        return [subdata for subdata in self.left.find(data) if self.right.find(data)]
+
+    def __str__(self):
+        return '%s where %s' % (self.left, self.right)
+
+    def __eq__(self, other):
+        return isinstance(other, Where) and other.left == self.left and other.right == self.right
+
+class Descendants(JSONPath):
+    """
+    JSONPath that matches first the left expression then any descendant
+    of it which matches the right expression.
+    """
+    
+    def __init__(self, left, right):
+        self.left = left
+        self.right = right
+
+    def find(self, datum):
+        # <left> .. <right> ==> <left> . (<right> | *..<right> | [*]..<right>)
+        #
+        # With with a wonky caveat that since Slice() has funky coercions
+        # we cannot just delegate to that equivalence or we'll hit an 
+        # infinite loop. So right here we implement the coercion-free version.
+
+        # Get all left matches into a list
+        left_matches = self.left.find(datum)
+        if not isinstance(left_matches, list):
+            left_matches = [left_matches]
+
+        def match_recursively(datum):
+            right_matches = self.right.find(datum)
+
+            # Manually do the * or [*] to avoid coercion and recurse just the right-hand pattern
+            if isinstance(datum.value, list):
+                recursive_matches = [submatch
+                                     for i in range(0, len(datum.value))
+                                     for submatch in match_recursively(DatumInContext(datum.value[i], context=datum, path=Index(i)))]
+
+            elif isinstance(datum.value, dict):
+                recursive_matches = [submatch
+                                     for field in datum.value.keys()
+                                     for submatch in match_recursively(DatumInContext(datum.value[field], context=datum, path=Fields(field)))]
+
+            else:
+                recursive_matches = []
+
+            return right_matches + list(recursive_matches)
+                
+        # TODO: repeatable iterator instead of list?
+        return [submatch
+                for left_match in left_matches
+                for submatch in match_recursively(left_match)]
+            
+    def is_singular():
+        return False
+
+    def __str__(self):
+        return '%s..%s' % (self.left, self.right)
+
+    def __eq__(self, other):
+        return isinstance(other, Descendants) and self.left == other.left and self.right == other.right
+
+class Union(JSONPath):
+    """
+    JSONPath that returns the union of the results of each match.
+    This is pretty shoddily implemented for now. The nicest semantics
+    in case of mismatched bits (list vs atomic) is to put
+    them all in a list, but I haven't done that yet.
+
+    WARNING: Any appearance of this being the _concatenation_ is
+    coincidence. It may even be a bug! (or laziness)
+    """
+    def __init__(self, left, right):
+        self.left = left
+        self.right = right
+
+    def is_singular(self):
+        return False
+
+    def find(self, data):
+        return self.left.find(data) + self.right.find(data)
+
+class Intersect(JSONPath):
+    """
+    JSONPath for bits that match *both* patterns.
+
+    This can be accomplished a couple of ways. The most
+    efficient is to actually build the intersected
+    AST as in building a state machine for matching the
+    intersection of regular languages. The next
+    idea is to build a filtered data and match against
+    that.
+    """
+    def __init__(self, left, right):
+        self.left = left
+        self.right = right
+
+    def is_singular(self):
+        return False
+
+    def find(self, data):
+        raise NotImplementedError()
+
+class Fields(JSONPath):
+    """
+    JSONPath referring to some field of the current object.
+    Concrete syntax ix comma-separated field names.
+
+    WARNING: If '*' is any of the field names, then they will
+    all be returned.
+    """
+    
+    def __init__(self, *fields):
+        self.fields = fields
+
+    def get_field_datum(self, datum, field):
+        if field == auto_id_field:
+            return AutoIdForDatum(datum)
+        else:
+            try:
+                field_value = datum.value[field] # Do NOT use `val.get(field)` since that confuses None as a value and None due to `get`
+                return DatumInContext(value=field_value, path=Fields(field), context=datum)
+            except (TypeError, KeyError, AttributeError):
+                return None
+
+    def reified_fields(self, datum):
+        if '*' not in self.fields:
+            return self.fields
+        else:
+            try:
+                fields = tuple(datum.value.keys())
+                return fields if auto_id_field is None else fields + (auto_id_field,)
+            except AttributeError:
+                return ()
+
+    def find(self, datum):
+        datum  = DatumInContext.wrap(datum)
+        
+        return  [field_datum
+                 for field_datum in [self.get_field_datum(datum, field) for field in self.reified_fields(datum)]
+                 if field_datum is not None]
+
+    def __str__(self):
+        return ','.join(self.fields)
+
+    def __repr__(self):
+        return '%s(%s)' % (self.__class__.__name__, ','.join(map(repr, self.fields)))
+
+    def __eq__(self, other):
+        return isinstance(other, Fields) and tuple(self.fields) == tuple(other.fields)
+
+
+class Index(JSONPath):
+    """
+    JSONPath that matches indices of the current datum, or none if not large enough.
+    Concrete syntax is brackets. 
+
+    WARNING: If the datum is not long enough, it will not crash but will not match anything.
+    NOTE: For the concrete syntax of `[*]`, the abstract syntax is a Slice() with no parameters (equiv to `[:]`
+    """
+
+    def __init__(self, index):
+        self.index = index
+
+    def find(self, datum):
+        datum = DatumInContext.wrap(datum)
+        
+        if len(datum.value) > self.index:
+            return [DatumInContext(datum.value[self.index], path=self, context=datum)]
+        else:
+            return []
+
+    def __eq__(self, other):
+        return isinstance(other, Index) and self.index == other.index
+
+    def __str__(self):
+        return '[%i]' % self.index
+
+class Slice(JSONPath):
+    """
+    JSONPath matching a slice of an array. 
+
+    Because of a mismatch between JSON and XML when schema-unaware,
+    this always returns an iterable; if the incoming data
+    was not a list, then it returns a one element list _containing_ that
+    data.
+
+    Consider these two docs, and their schema-unaware translation to JSON:
+    
+    <a><b>hello</b></a> ==> {"a": {"b": "hello"}}
+    <a><b>hello</b><b>goodbye</b></a> ==> {"a": {"b": ["hello", "goodbye"]}}
+
+    If there were a schema, it would be known that "b" should always be an
+    array (unless the schema were wonky, but that is too much to fix here)
+    so when querying with JSON if the one writing the JSON knows that it
+    should be an array, they can write a slice operator and it will coerce
+    a non-array value to an array.
+
+    This may be a bit unfortunate because it would be nice to always have
+    an iterator, but dictionaries and other objects may also be iterable,
+    so this is the compromise.
+    """
+    def __init__(self, start=None, end=None, step=None):
+        self.start = start
+        self.end = end
+        self.step = step
+    
+    def find(self, datum):
+        datum = DatumInContext.wrap(datum)
+        
+        # Here's the hack. If it is a dictionary or some kind of constant,
+        # put it in a single-element list
+        if (isinstance(datum.value, dict) or isinstance(datum.value, six.integer_types) or isinstance(datum.value, six.string_types)):
+            return self.find(DatumInContext([datum.value], path=datum.path, context=datum.context))
+
+        # Some iterators do not support slicing but we can still
+        # at least work for '*'
+        if self.start == None and self.end == None and self.step == None:
+            return [DatumInContext(datum.value[i], path=Index(i), context=datum) for i in xrange(0, len(datum.value))]
+        else:
+            return [DatumInContext(datum.value[i], path=Index(i), context=datum) for i in range(0, len(datum.value))[self.start:self.end:self.step]]
+
+    def __str__(self):
+        if self.start == None and self.end == None and self.step == None:
+            return '[*]'
+        else:
+            return '[%s%s%s]' % (self.start or '', 
+                                   ':%d'%self.end if self.end else '',
+                                   ':%d'%self.step if self.step else '')
+
+    def __repr__(self):
+        return '%s(start=%r,end=%r,step=%r)' % (self.__class__.__name__, self.start, self.end, self.step)
+
+    def __eq__(self, other):
+        return isinstance(other, Slice) and other.start == self.start and self.end == other.end and other.step == self.step

bin/jsonpath_rw/lexer.py

@@ -0,0 +1,171 @@
+from __future__ import unicode_literals, print_function, absolute_import, division, generators, nested_scopes
+import sys
+import logging
+
+import ply.lex
+
+logger = logging.getLogger(__name__)
+
+class JsonPathLexerError(Exception):
+    pass
+
+class JsonPathLexer(object):
+    '''
+    A Lexical analyzer for JsonPath.
+    '''
+
+    def __init__(self, debug=False):
+        self.debug = debug
+        if self.__doc__ == None:
+            raise JsonPathLexerError('Docstrings have been removed! By design of PLY, jsonpath-rw requires docstrings. You must not use PYTHONOPTIMIZE=2 or python -OO.')
+
+    def tokenize(self, string):
+        '''
+        Maps a string to an iterator over tokens. In other words: [char] -> [token]
+        '''
+
+        new_lexer = ply.lex.lex(module=self, debug=self.debug, errorlog=logger)
+        new_lexer.latest_newline = 0
+        new_lexer.string_value = None
+        new_lexer.input(string)
+
+        while True:
+            t = new_lexer.token()
+            if t is None: break
+            t.col = t.lexpos - new_lexer.latest_newline
+            yield t
+
+        if new_lexer.string_value is not None:
+            raise JsonPathLexerError('Unexpected EOF in string literal or identifier')
+
+    # ============== PLY Lexer specification ==================
+    #
+    # This probably should be private but:
+    #   - the parser requires access to `tokens` (perhaps they should be defined in a third, shared dependency)
+    #   - things like `literals` might be a legitimate part of the public interface.
+    #
+    # Anyhow, it is pythonic to give some rope to hang oneself with :-)
+
+    literals = ['*', '.', '[', ']', '(', ')', '$', ',', ':', '|', '&']
+
+    reserved_words = { 'where': 'WHERE' }
+
+    tokens = ['DOUBLEDOT', 'NUMBER', 'ID', 'NAMED_OPERATOR'] + list(reserved_words.values())
+
+    states = [ ('singlequote', 'exclusive'),
+               ('doublequote', 'exclusive'),
+               ('backquote', 'exclusive') ]
+
+    # Normal lexing, rather easy
+    t_DOUBLEDOT = r'\.\.'
+    t_ignore = ' \t'
+
+    def t_ID(self, t):
+        r'[a-zA-Z_@][a-zA-Z0-9_@\-]*'
+        t.type = self.reserved_words.get(t.value, 'ID')
+        return t
+
+    def t_NUMBER(self, t):
+        r'-?\d+'
+        t.value = int(t.value)
+        return t
+
+
+    # Single-quoted strings
+    t_singlequote_ignore = ''
+    def t_singlequote(self, t):
+        r"'"
+        t.lexer.string_start = t.lexer.lexpos
+        t.lexer.string_value = ''
+        t.lexer.push_state('singlequote')
+
+    def t_singlequote_content(self, t):
+        r"[^'\\]+"
+        t.lexer.string_value += t.value
+
+    def t_singlequote_escape(self, t):
+        r'\\.'
+        t.lexer.string_value += t.value[1]
+
+    def t_singlequote_end(self, t):
+        r"'"
+        t.value = t.lexer.string_value
+        t.type = 'ID'
+        t.lexer.string_value = None
+        t.lexer.pop_state()
+        return t
+
+    def t_singlequote_error(self, t):
+        raise JsonPathLexerError('Error on line %s, col %s while lexing singlequoted field: Unexpected character: %s ' % (t.lexer.lineno, t.lexpos - t.lexer.latest_newline, t.value[0]))
+
+
+    # Double-quoted strings
+    t_doublequote_ignore = ''
+    def t_doublequote(self, t):
+        r'"'
+        t.lexer.string_start = t.lexer.lexpos
+        t.lexer.string_value = ''
+        t.lexer.push_state('doublequote')
+
+    def t_doublequote_content(self, t):
+        r'[^"\\]+'
+        t.lexer.string_value += t.value
+
+    def t_doublequote_escape(self, t):
+        r'\\.'
+        t.lexer.string_value += t.value[1]
+
+    def t_doublequote_end(self, t):
+        r'"'
+        t.value = t.lexer.string_value
+        t.type = 'ID'
+        t.lexer.string_value = None
+        t.lexer.pop_state()
+        return t
+
+    def t_doublequote_error(self, t):
+        raise JsonPathLexerError('Error on line %s, col %s while lexing doublequoted field: Unexpected character: %s ' % (t.lexer.lineno, t.lexpos - t.lexer.latest_newline, t.value[0]))
+
+
+    # Back-quoted "magic" operators
+    t_backquote_ignore = ''
+    def t_backquote(self, t):
+        r'`'
+        t.lexer.string_start = t.lexer.lexpos
+        t.lexer.string_value = ''
+        t.lexer.push_state('backquote')
+
+    def t_backquote_escape(self, t):
+        r'\\.'
+        t.lexer.string_value += t.value[1]
+
+    def t_backquote_content(self, t):
+        r"[^`\\]+"
+        t.lexer.string_value += t.value
+
+    def t_backquote_end(self, t):
+        r'`'
+        t.value = t.lexer.string_value
+        t.type = 'NAMED_OPERATOR'
+        t.lexer.string_value = None
+        t.lexer.pop_state()
+        return t
+
+    def t_backquote_error(self, t):
+        raise JsonPathLexerError('Error on line %s, col %s while lexing backquoted operator: Unexpected character: %s ' % (t.lexer.lineno, t.lexpos - t.lexer.latest_newline, t.value[0]))
+
+
+    # Counting lines, handling errors
+    def t_newline(self, t):
+        r'\n'
+        t.lexer.lineno += 1
+        t.lexer.latest_newline = t.lexpos
+
+    def t_error(self, t):
+        raise JsonPathLexerError('Error on line %s, col %s: Unexpected character: %s ' % (t.lexer.lineno, t.lexpos - t.lexer.latest_newline, t.value[0]))
+
+if __name__ == '__main__':
+    logging.basicConfig()
+    lexer = JsonPathLexer(debug=True)
+    for token in lexer.tokenize(sys.stdin.read()):
+        print('%-20s%s' % (token.value, token.type))

bin/jsonpath_rw/parser.py

@@ -0,0 +1,187 @@
+from __future__ import print_function, absolute_import, division, generators, nested_scopes
+import sys
+import os.path
+import logging
+
+import ply.yacc
+
+from jsonpath_rw.jsonpath import *
+from jsonpath_rw.lexer import JsonPathLexer
+
+logger = logging.getLogger(__name__)
+
+def parse(string):
+    return JsonPathParser().parse(string)
+
+class JsonPathParser(object):
+    '''
+    An LALR-parser for JsonPath
+    '''
+    
+    tokens = JsonPathLexer.tokens
+
+    def __init__(self, debug=False, lexer_class=None):
+        if self.__doc__ == None:
+            raise Exception('Docstrings have been removed! By design of PLY, jsonpath-rw requires docstrings. You must not use PYTHONOPTIMIZE=2 or python -OO.')
+
+        self.debug = debug
+        self.lexer_class = lexer_class or JsonPathLexer # Crufty but works around statefulness in PLY
+
+    def parse(self, string, lexer = None):
+        lexer = lexer or self.lexer_class()
+        return self.parse_token_stream(lexer.tokenize(string))
+
+    def parse_token_stream(self, token_iterator, start_symbol='jsonpath'):
+
+        # Since PLY has some crufty aspects and dumps files, we try to keep them local
+        # However, we need to derive the name of the output Python file :-/
+        output_directory = os.path.dirname(__file__)
+        try:
+            module_name = os.path.splitext(os.path.split(__file__)[1])[0]
+        except:
+            module_name = __name__
+        
+        parsing_table_module = '_'.join([module_name, start_symbol, 'parsetab'])
+
+        # And we regenerate the parse table every time; it doesn't actually take that long!
+        new_parser = ply.yacc.yacc(module=self,
+                                   debug=self.debug,
+                                   tabmodule = parsing_table_module,
+                                   outputdir = output_directory,
+                                   write_tables=0,
+                                   start = start_symbol,
+                                   errorlog = logger)
+
+        return new_parser.parse(lexer = IteratorToTokenStream(token_iterator))
+
+    # ===================== PLY Parser specification =====================
+    
+    precedence = [
+        ('left', ','),
+        ('left', 'DOUBLEDOT'),
+        ('left', '.'),
+        ('left', '|'),
+        ('left', '&'),
+        ('left', 'WHERE'),
+    ]
+
+    def p_error(self, t):
+        raise Exception('Parse error at %s:%s near token %s (%s)' % (t.lineno, t.col, t.value, t.type)) 
+
+    def p_jsonpath_binop(self, p):
+        """jsonpath : jsonpath '.' jsonpath 
+                    | jsonpath DOUBLEDOT jsonpath
+                    | jsonpath WHERE jsonpath
+                    | jsonpath '|' jsonpath
+                    | jsonpath '&' jsonpath"""
+        op = p[2]
+
+        if op == '.':
+            p[0] = Child(p[1], p[3])
+        elif op == '..':
+            p[0] = Descendants(p[1], p[3])
+        elif op == 'where':
+            p[0] = Where(p[1], p[3])
+        elif op == '|':
+            p[0] = Union(p[1], p[3])
+        elif op == '&':
+            p[0] = Intersect(p[1], p[3])
+
+    def p_jsonpath_fields(self, p):
+        "jsonpath : fields_or_any"
+        p[0] = Fields(*p[1])
+
+    def p_jsonpath_named_operator(self, p):
+        "jsonpath : NAMED_OPERATOR"
+        if p[1] == 'this':
+            p[0] = This()
+        elif p[1] == 'parent':
+            p[0] = Parent()
+        else:
+            raise Exception('Unknown named operator `%s` at %s:%s' % (p[1], p.lineno(1), p.lexpos(1)))
+
+    def p_jsonpath_root(self, p):
+        "jsonpath : '$'"
+        p[0] = Root()
+
+    def p_jsonpath_idx(self, p):
+        "jsonpath : '[' idx ']'"
+        p[0] = p[2]
+
+    def p_jsonpath_slice(self, p):
+        "jsonpath : '[' slice ']'"
+        p[0] = p[2]
+
+    def p_jsonpath_fieldbrackets(self, p):
+        "jsonpath : '[' fields ']'"
+        p[0] = Fields(*p[2])
+
+    def p_jsonpath_child_fieldbrackets(self, p):
+        "jsonpath : jsonpath '[' fields ']'"
+        p[0] = Child(p[1], Fields(*p[3]))
+
+    def p_jsonpath_child_idxbrackets(self, p):
+        "jsonpath : jsonpath '[' idx ']'"
+        p[0] = Child(p[1], p[3])
+
+    def p_jsonpath_child_slicebrackets(self, p):
+        "jsonpath : jsonpath '[' slice ']'"
+        p[0] = Child(p[1], p[3])
+
+    def p_jsonpath_parens(self, p):
+        "jsonpath : '(' jsonpath ')'"
+        p[0] = p[2]
+
+    # Because fields in brackets cannot be '*' - that is reserved for array indices
+    def p_fields_or_any(self, p):
+        """fields_or_any : fields 
+                         | '*'    """
+        if p[1] == '*':
+            p[0] = ['*']
+        else:
+            p[0] = p[1]
+
+    def p_fields_id(self, p):
+        "fields : ID"
+        p[0] = [p[1]]
+
+    def p_fields_comma(self, p):
+        "fields : fields ',' fields"
+        p[0] = p[1] + p[3]
+
+    def p_idx(self, p):
+        "idx : NUMBER"
+        p[0] = Index(p[1])
+
+    def p_slice_any(self, p):
+        "slice : '*'"
+        p[0] = Slice()
+
+    def p_slice(self, p): # Currently does not support `step`
+        "slice : maybe_int ':' maybe_int"
+        p[0] = Slice(start=p[1], end=p[3])
+
+    def p_maybe_int(self, p):
+        """maybe_int : NUMBER
+                     | empty"""
+        p[0] = p[1]
+    
+    def p_empty(self, p):
+        'empty :'
+        p[0] = None
+
+class IteratorToTokenStream(object):
+    def __init__(self, iterator):
+        self.iterator = iterator
+
+    def token(self):
+        try:
+            return next(self.iterator)
+        except StopIteration:
+            return None
+
+
+if __name__ == '__main__':
+    logging.basicConfig()
+    parser = JsonPathParser(debug=True)
+    print(parser.parse(sys.stdin.read()))

bin/network-build

@@ -1,6 +0,0 @@
-#!/bin/sh -x
-
-cd ~/NewCoin
-git pull
-scons -j 2
-cp -p newcoind bin/

bin/network-init

@@ -1,10 +0,0 @@
-#!/bin/sh
-
-# XXX Should not need to make db directory. newcoind should do this.
-for SITE in $HOSTS
-do
-	echo "Clearing db for:" $SITE
-	DB_DIR="/var/www/$SITE/db/"
-	mkdir -p "/var/www/$SITE/db/"
-	rm -rf "/var/www/$SITE/db/*"
-done

bin/network-restart

@@ -1,5 +0,0 @@
-#!/bin/sh -x
-
-network-stop
-sleep 1
-network-start

bin/network-start

@@ -1,6 +0,0 @@
-#!/bin/sh
-
-for SITE in $HOSTS
-do
-	(nx $SITE &)
-done

bin/network-stop

@@ -1,6 +0,0 @@
-#!/bin/sh
-
-for SITE in $HOSTS
-do
-	(nx $SITE stop &)
-done

bin/network-update

@@ -1,5 +0,0 @@
-#!/bin/sh -x
-echo "Building and restarting."
-
-network-build
-network-restart

bin/nx

@@ -1,7 +0,0 @@
-#!/bin/sh
-
-SITE=$1
-shift
-COMMAND=$@
-cd "/var/www/$SITE"
-newcoind $COMMAND 

bin/ply/__init__.py

@@ -0,0 +1,4 @@
+# PLY package
+# Author: David Beazley (dave@dabeaz.com)
+
+__all__ = ['lex','yacc']

bin/ply/cpp.py

@@ -0,0 +1,898 @@
+# -----------------------------------------------------------------------------
+# cpp.py
+#
+# Author:  David Beazley (http://www.dabeaz.com)
+# Copyright (C) 2007
+# All rights reserved
+#
+# This module implements an ANSI-C style lexical preprocessor for PLY. 
+# -----------------------------------------------------------------------------
+from __future__ import generators
+
+# -----------------------------------------------------------------------------
+# Default preprocessor lexer definitions.   These tokens are enough to get
+# a basic preprocessor working.   Other modules may import these if they want
+# -----------------------------------------------------------------------------
+
+tokens = (
+   'CPP_ID','CPP_INTEGER', 'CPP_FLOAT', 'CPP_STRING', 'CPP_CHAR', 'CPP_WS', 'CPP_COMMENT', 'CPP_POUND','CPP_DPOUND'
+)
+
+literals = "+-*/%|&~^<>=!?()[]{}.,;:\\\'\""
+
+# Whitespace
+def t_CPP_WS(t):
+    r'\s+'
+    t.lexer.lineno += t.value.count("\n")
+    return t
+
+t_CPP_POUND = r'\#'
+t_CPP_DPOUND = r'\#\#'
+
+# Identifier
+t_CPP_ID = r'[A-Za-z_][\w_]*'
+
+# Integer literal
+def CPP_INTEGER(t):
+    r'(((((0x)|(0X))[0-9a-fA-F]+)|(\d+))([uU]|[lL]|[uU][lL]|[lL][uU])?)'
+    return t
+
+t_CPP_INTEGER = CPP_INTEGER
+
+# Floating literal
+t_CPP_FLOAT = r'((\d+)(\.\d+)(e(\+|-)?(\d+))? | (\d+)e(\+|-)?(\d+))([lL]|[fF])?'
+
+# String literal
+def t_CPP_STRING(t):
+    r'\"([^\\\n]|(\\(.|\n)))*?\"'
+    t.lexer.lineno += t.value.count("\n")
+    return t
+
+# Character constant 'c' or L'c'
+def t_CPP_CHAR(t):
+    r'(L)?\'([^\\\n]|(\\(.|\n)))*?\''
+    t.lexer.lineno += t.value.count("\n")
+    return t
+
+# Comment
+def t_CPP_COMMENT(t):
+    r'(/\*(.|\n)*?\*/)|(//.*?\n)'
+    t.lexer.lineno += t.value.count("\n")
+    return t
+    
+def t_error(t):
+    t.type = t.value[0]
+    t.value = t.value[0]
+    t.lexer.skip(1)
+    return t
+
+import re
+import copy
+import time
+import os.path
+
+# -----------------------------------------------------------------------------
+# trigraph()
+# 
+# Given an input string, this function replaces all trigraph sequences. 
+# The following mapping is used:
+#
+#     ??=    #
+#     ??/    \
+#     ??'    ^
+#     ??(    [
+#     ??)    ]
+#     ??!    |
+#     ??<    {
+#     ??>    }
+#     ??-    ~
+# -----------------------------------------------------------------------------
+
+_trigraph_pat = re.compile(r'''\?\?[=/\'\(\)\!<>\-]''')
+_trigraph_rep = {
+    '=':'#',
+    '/':'\\',
+    "'":'^',
+    '(':'[',
+    ')':']',
+    '!':'|',
+    '<':'{',
+    '>':'}',
+    '-':'~'
+}
+
+def trigraph(input):
+    return _trigraph_pat.sub(lambda g: _trigraph_rep[g.group()[-1]],input)
+
+# ------------------------------------------------------------------
+# Macro object
+#
+# This object holds information about preprocessor macros
+#
+#    .name      - Macro name (string)
+#    .value     - Macro value (a list of tokens)
+#    .arglist   - List of argument names
+#    .variadic  - Boolean indicating whether or not variadic macro
+#    .vararg    - Name of the variadic parameter
+#
+# When a macro is created, the macro replacement token sequence is
+# pre-scanned and used to create patch lists that are later used
+# during macro expansion
+# ------------------------------------------------------------------
+
+class Macro(object):
+    def __init__(self,name,value,arglist=None,variadic=False):
+        self.name = name
+        self.value = value
+        self.arglist = arglist
+        self.variadic = variadic
+        if variadic:
+            self.vararg = arglist[-1]
+        self.source = None
+
+# ------------------------------------------------------------------
+# Preprocessor object
+#
+# Object representing a preprocessor.  Contains macro definitions,
+# include directories, and other information
+# ------------------------------------------------------------------
+
+class Preprocessor(object):
+    def __init__(self,lexer=None):
+        if lexer is None:
+            lexer = lex.lexer
+        self.lexer = lexer
+        self.macros = { }
+        self.path = []
+        self.temp_path = []
+
+        # Probe the lexer for selected tokens
+        self.lexprobe()
+
+        tm = time.localtime()
+        self.define("__DATE__ \"%s\"" % time.strftime("%b %d %Y",tm))
+        self.define("__TIME__ \"%s\"" % time.strftime("%H:%M:%S",tm))
+        self.parser = None
+
+    # -----------------------------------------------------------------------------
+    # tokenize()
+    #
+    # Utility function. Given a string of text, tokenize into a list of tokens
+    # -----------------------------------------------------------------------------
+
+    def tokenize(self,text):
+        tokens = []
+        self.lexer.input(text)
+        while True:
+            tok = self.lexer.token()
+            if not tok: break
+            tokens.append(tok)
+        return tokens
+
+    # ---------------------------------------------------------------------
+    # error()
+    #
+    # Report a preprocessor error/warning of some kind
+    # ----------------------------------------------------------------------
+
+    def error(self,file,line,msg):
+        print("%s:%d %s" % (file,line,msg))
+
+    # ----------------------------------------------------------------------
+    # lexprobe()
+    #
+    # This method probes the preprocessor lexer object to discover
+    # the token types of symbols that are important to the preprocessor.
+    # If this works right, the preprocessor will simply "work"
+    # with any suitable lexer regardless of how tokens have been named.
+    # ----------------------------------------------------------------------
+
+    def lexprobe(self):
+
+        # Determine the token type for identifiers
+        self.lexer.input("identifier")
+        tok = self.lexer.token()
+        if not tok or tok.value != "identifier":
+            print("Couldn't determine identifier type")
+        else:
+            self.t_ID = tok.type
+
+        # Determine the token type for integers
+        self.lexer.input("12345")
+        tok = self.lexer.token()
+        if not tok or int(tok.value) != 12345:
+            print("Couldn't determine integer type")
+        else:
+            self.t_INTEGER = tok.type
+            self.t_INTEGER_TYPE = type(tok.value)
+
+        # Determine the token type for strings enclosed in double quotes
+        self.lexer.input("\"filename\"")
+        tok = self.lexer.token()
+        if not tok or tok.value != "\"filename\"":
+            print("Couldn't determine string type")
+        else:
+            self.t_STRING = tok.type
+
+        # Determine the token type for whitespace--if any
+        self.lexer.input("  ")
+        tok = self.lexer.token()
+        if not tok or tok.value != "  ":
+            self.t_SPACE = None
+        else:
+            self.t_SPACE = tok.type
+
+        # Determine the token type for newlines
+        self.lexer.input("\n")
+        tok = self.lexer.token()
+        if not tok or tok.value != "\n":
+            self.t_NEWLINE = None
+            print("Couldn't determine token for newlines")
+        else:
+            self.t_NEWLINE = tok.type
+
+        self.t_WS = (self.t_SPACE, self.t_NEWLINE)
+
+        # Check for other characters used by the preprocessor
+        chars = [ '<','>','#','##','\\','(',')',',','.']
+        for c in chars:
+            self.lexer.input(c)
+            tok = self.lexer.token()
+            if not tok or tok.value != c:
+                print("Unable to lex '%s' required for preprocessor" % c)
+
+    # ----------------------------------------------------------------------
+    # add_path()
+    #
+    # Adds a search path to the preprocessor.  
+    # ----------------------------------------------------------------------
+
+    def add_path(self,path):
+        self.path.append(path)
+
+    # ----------------------------------------------------------------------
+    # group_lines()
+    #
+    # Given an input string, this function splits it into lines.  Trailing whitespace
+    # is removed.   Any line ending with \ is grouped with the next line.  This
+    # function forms the lowest level of the preprocessor---grouping into text into
+    # a line-by-line format.
+    # ----------------------------------------------------------------------
+
+    def group_lines(self,input):
+        lex = self.lexer.clone()
+        lines = [x.rstrip() for x in input.splitlines()]
+        for i in xrange(len(lines)):
+            j = i+1
+            while lines[i].endswith('\\') and (j < len(lines)):
+                lines[i] = lines[i][:-1]+lines[j]
+                lines[j] = ""
+                j += 1
+
+        input = "\n".join(lines)
+        lex.input(input)
+        lex.lineno = 1
+
+        current_line = []
+        while True:
+            tok = lex.token()
+            if not tok:
+                break
+            current_line.append(tok)
+            if tok.type in self.t_WS and '\n' in tok.value:
+                yield current_line
+                current_line = []
+
+        if current_line:
+            yield current_line
+
+    # ----------------------------------------------------------------------
+    # tokenstrip()
+    # 
+    # Remove leading/trailing whitespace tokens from a token list
+    # ----------------------------------------------------------------------
+
+    def tokenstrip(self,tokens):
+        i = 0
+        while i < len(tokens) and tokens[i].type in self.t_WS:
+            i += 1
+        del tokens[:i]
+        i = len(tokens)-1
+        while i >= 0 and tokens[i].type in self.t_WS:
+            i -= 1
+        del tokens[i+1:]
+        return tokens
+
+
+    # ----------------------------------------------------------------------
+    # collect_args()
+    #
+    # Collects comma separated arguments from a list of tokens.   The arguments
+    # must be enclosed in parenthesis.  Returns a tuple (tokencount,args,positions)
+    # where tokencount is the number of tokens consumed, args is a list of arguments,
+    # and positions is a list of integers containing the starting index of each
+    # argument.  Each argument is represented by a list of tokens.
+    #
+    # When collecting arguments, leading and trailing whitespace is removed
+    # from each argument.  
+    #
+    # This function properly handles nested parenthesis and commas---these do not
+    # define new arguments.
+    # ----------------------------------------------------------------------
+
+    def collect_args(self,tokenlist):
+        args = []
+        positions = []
+        current_arg = []
+        nesting = 1
+        tokenlen = len(tokenlist)
+    
+        # Search for the opening '('.
+        i = 0
+        while (i < tokenlen) and (tokenlist[i].type in self.t_WS):
+            i += 1
+
+        if (i < tokenlen) and (tokenlist[i].value == '('):
+            positions.append(i+1)
+        else:
+            self.error(self.source,tokenlist[0].lineno,"Missing '(' in macro arguments")
+            return 0, [], []
+
+        i += 1
+
+        while i < tokenlen:
+            t = tokenlist[i]
+            if t.value == '(':
+                current_arg.append(t)
+                nesting += 1
+            elif t.value == ')':
+                nesting -= 1
+                if nesting == 0:
+                    if current_arg:
+                        args.append(self.tokenstrip(current_arg))
+                        positions.append(i)
+                    return i+1,args,positions
+                current_arg.append(t)
+            elif t.value == ',' and nesting == 1:
+                args.append(self.tokenstrip(current_arg))
+                positions.append(i+1)
+                current_arg = []
+            else:
+                current_arg.append(t)
+            i += 1
+    
+        # Missing end argument
+        self.error(self.source,tokenlist[-1].lineno,"Missing ')' in macro arguments")
+        return 0, [],[]
+
+    # ----------------------------------------------------------------------
+    # macro_prescan()
+    #
+    # Examine the macro value (token sequence) and identify patch points
+    # This is used to speed up macro expansion later on---we'll know
+    # right away where to apply patches to the value to form the expansion
+    # ----------------------------------------------------------------------
+    
+    def macro_prescan(self,macro):
+        macro.patch     = []             # Standard macro arguments 
+        macro.str_patch = []             # String conversion expansion
+        macro.var_comma_patch = []       # Variadic macro comma patch
+        i = 0
+        while i < len(macro.value):
+            if macro.value[i].type == self.t_ID and macro.value[i].value in macro.arglist:
+                argnum = macro.arglist.index(macro.value[i].value)
+                # Conversion of argument to a string
+                if i > 0 and macro.value[i-1].value == '#':
+                    macro.value[i] = copy.copy(macro.value[i])
+                    macro.value[i].type = self.t_STRING
+                    del macro.value[i-1]
+                    macro.str_patch.append((argnum,i-1))
+                    continue
+                # Concatenation
+                elif (i > 0 and macro.value[i-1].value == '##'):
+                    macro.patch.append(('c',argnum,i-1))
+                    del macro.value[i-1]
+                    continue
+                elif ((i+1) < len(macro.value) and macro.value[i+1].value == '##'):
+                    macro.patch.append(('c',argnum,i))
+                    i += 1
+                    continue
+                # Standard expansion
+                else:
+                    macro.patch.append(('e',argnum,i))
+            elif macro.value[i].value == '##':
+                if macro.variadic and (i > 0) and (macro.value[i-1].value == ',') and \
+                        ((i+1) < len(macro.value)) and (macro.value[i+1].type == self.t_ID) and \
+                        (macro.value[i+1].value == macro.vararg):
+                    macro.var_comma_patch.append(i-1)
+            i += 1
+        macro.patch.sort(key=lambda x: x[2],reverse=True)
+
+    # ----------------------------------------------------------------------
+    # macro_expand_args()
+    #
+    # Given a Macro and list of arguments (each a token list), this method
+    # returns an expanded version of a macro.  The return value is a token sequence
+    # representing the replacement macro tokens
+    # ----------------------------------------------------------------------
+
+    def macro_expand_args(self,macro,args):
+        # Make a copy of the macro token sequence
+        rep = [copy.copy(_x) for _x in macro.value]
+
+        # Make string expansion patches.  These do not alter the length of the replacement sequence
+        
+        str_expansion = {}
+        for argnum, i in macro.str_patch:
+            if argnum not in str_expansion:
+                str_expansion[argnum] = ('"%s"' % "".join([x.value for x in args[argnum]])).replace("\\","\\\\")
+            rep[i] = copy.copy(rep[i])
+            rep[i].value = str_expansion[argnum]
+
+        # Make the variadic macro comma patch.  If the variadic macro argument is empty, we get rid
+        comma_patch = False
+        if macro.variadic and not args[-1]:
+            for i in macro.var_comma_patch:
+                rep[i] = None
+                comma_patch = True
+
+        # Make all other patches.   The order of these matters.  It is assumed that the patch list
+        # has been sorted in reverse order of patch location since replacements will cause the
+        # size of the replacement sequence to expand from the patch point.
+        
+        expanded = { }
+        for ptype, argnum, i in macro.patch:
+            # Concatenation.   Argument is left unexpanded
+            if ptype == 'c':
+                rep[i:i+1] = args[argnum]
+            # Normal expansion.  Argument is macro expanded first
+            elif ptype == 'e':
+                if argnum not in expanded:
+                    expanded[argnum] = self.expand_macros(args[argnum])
+                rep[i:i+1] = expanded[argnum]
+
+        # Get rid of removed comma if necessary
+        if comma_patch:
+            rep = [_i for _i in rep if _i]
+
+        return rep
+
+
+    # ----------------------------------------------------------------------
+    # expand_macros()
+    #
+    # Given a list of tokens, this function performs macro expansion.
+    # The expanded argument is a dictionary that contains macros already
+    # expanded.  This is used to prevent infinite recursion.
+    # ----------------------------------------------------------------------
+
+    def expand_macros(self,tokens,expanded=None):
+        if expanded is None:
+            expanded = {}
+        i = 0
+        while i < len(tokens):
+            t = tokens[i]
+            if t.type == self.t_ID:
+                if t.value in self.macros and t.value not in expanded:
+                    # Yes, we found a macro match
+                    expanded[t.value] = True
+                    
+                    m = self.macros[t.value]
+                    if not m.arglist:
+                        # A simple macro
+                        ex = self.expand_macros([copy.copy(_x) for _x in m.value],expanded)
+                        for e in ex:
+                            e.lineno = t.lineno
+                        tokens[i:i+1] = ex
+                        i += len(ex)
+                    else:
+                        # A macro with arguments
+                        j = i + 1
+                        while j < len(tokens) and tokens[j].type in self.t_WS:
+                            j += 1
+                        if tokens[j].value == '(':
+                            tokcount,args,positions = self.collect_args(tokens[j:])
+                            if not m.variadic and len(args) !=  len(m.arglist):
+                                self.error(self.source,t.lineno,"Macro %s requires %d arguments" % (t.value,len(m.arglist)))
+                                i = j + tokcount
+                            elif m.variadic and len(args) < len(m.arglist)-1:
+                                if len(m.arglist) > 2:
+                                    self.error(self.source,t.lineno,"Macro %s must have at least %d arguments" % (t.value, len(m.arglist)-1))
+                                else:
+                                    self.error(self.source,t.lineno,"Macro %s must have at least %d argument" % (t.value, len(m.arglist)-1))
+                                i = j + tokcount
+                            else:
+                                if m.variadic:
+                                    if len(args) == len(m.arglist)-1:
+                                        args.append([])
+                                    else:
+                                        args[len(m.arglist)-1] = tokens[j+positions[len(m.arglist)-1]:j+tokcount-1]
+                                        del args[len(m.arglist):]
+                                        
+                                # Get macro replacement text
+                                rep = self.macro_expand_args(m,args)
+                                rep = self.expand_macros(rep,expanded)
+                                for r in rep:
+                                    r.lineno = t.lineno
+                                tokens[i:j+tokcount] = rep
+                                i += len(rep)
+                    del expanded[t.value]
+                    continue
+                elif t.value == '__LINE__':
+                    t.type = self.t_INTEGER
+                    t.value = self.t_INTEGER_TYPE(t.lineno)
+                
+            i += 1
+        return tokens
+
+    # ----------------------------------------------------------------------    
+    # evalexpr()
+    # 
+    # Evaluate an expression token sequence for the purposes of evaluating
+    # integral expressions.
+    # ----------------------------------------------------------------------
+
+    def evalexpr(self,tokens):
+        # tokens = tokenize(line)
+        # Search for defined macros
+        i = 0
+        while i < len(tokens):
+            if tokens[i].type == self.t_ID and tokens[i].value == 'defined':
+                j = i + 1
+                needparen = False
+                result = "0L"
+                while j < len(tokens):
+                    if tokens[j].type in self.t_WS:
+                        j += 1
+                        continue
+                    elif tokens[j].type == self.t_ID:
+                        if tokens[j].value in self.macros:
+                            result = "1L"
+                        else:
+                            result = "0L"
+                        if not needparen: break
+                    elif tokens[j].value == '(':
+                        needparen = True
+                    elif tokens[j].value == ')':
+                        break
+                    else:
+                        self.error(self.source,tokens[i].lineno,"Malformed defined()")
+                    j += 1
+                tokens[i].type = self.t_INTEGER
+                tokens[i].value = self.t_INTEGER_TYPE(result)
+                del tokens[i+1:j+1]
+            i += 1
+        tokens = self.expand_macros(tokens)
+        for i,t in enumerate(tokens):
+            if t.type == self.t_ID:
+                tokens[i] = copy.copy(t)
+                tokens[i].type = self.t_INTEGER
+                tokens[i].value = self.t_INTEGER_TYPE("0L")
+            elif t.type == self.t_INTEGER:
+                tokens[i] = copy.copy(t)
+                # Strip off any trailing suffixes
+                tokens[i].value = str(tokens[i].value)
+                while tokens[i].value[-1] not in "0123456789abcdefABCDEF":
+                    tokens[i].value = tokens[i].value[:-1]
+        
+        expr = "".join([str(x.value) for x in tokens])
+        expr = expr.replace("&&"," and ")
+        expr = expr.replace("||"," or ")
+        expr = expr.replace("!"," not ")
+        try:
+            result = eval(expr)
+        except StandardError:
+            self.error(self.source,tokens[0].lineno,"Couldn't evaluate expression")
+            result = 0
+        return result
+
+    # ----------------------------------------------------------------------
+    # parsegen()
+    #
+    # Parse an input string/
+    # ----------------------------------------------------------------------
+    def parsegen(self,input,source=None):
+
+        # Replace trigraph sequences
+        t = trigraph(input)
+        lines = self.group_lines(t)
+
+        if not source:
+            source = ""
+            
+        self.define("__FILE__ \"%s\"" % source)
+
+        self.source = source
+        chunk = []
+        enable = True
+        iftrigger = False
+        ifstack = []
+
+        for x in lines:
+            for i,tok in enumerate(x):
+                if tok.type not in self.t_WS: break
+            if tok.value == '#':
+                # Preprocessor directive
+
+                for tok in x:
+                    if tok in self.t_WS and '\n' in tok.value:
+                        chunk.append(tok)
+                
+                dirtokens = self.tokenstrip(x[i+1:])
+                if dirtokens:
+                    name = dirtokens[0].value
+                    args = self.tokenstrip(dirtokens[1:])
+                else:
+                    name = ""
+                    args = []
+                
+                if name == 'define':
+                    if enable:
+                        for tok in self.expand_macros(chunk):
+                            yield tok
+                        chunk = []
+                        self.define(args)
+                elif name == 'include':
+                    if enable:
+                        for tok in self.expand_macros(chunk):
+                            yield tok
+                        chunk = []
+                        oldfile = self.macros['__FILE__']
+                        for tok in self.include(args):
+                            yield tok
+                        self.macros['__FILE__'] = oldfile
+                        self.source = source
+                elif name == 'undef':
+                    if enable:
+                        for tok in self.expand_macros(chunk):
+                            yield tok
+                        chunk = []
+                        self.undef(args)
+                elif name == 'ifdef':
+                    ifstack.append((enable,iftrigger))
+                    if enable:
+                        if not args[0].value in self.macros:
+                            enable = False
+                            iftrigger = False
+                        else:
+                            iftrigger = True
+                elif name == 'ifndef':
+                    ifstack.append((enable,iftrigger))
+                    if enable:
+                        if args[0].value in self.macros:
+                            enable = False
+                            iftrigger = False
+                        else:
+                            iftrigger = True
+                elif name == 'if':
+                    ifstack.append((enable,iftrigger))
+                    if enable:
+                        result = self.evalexpr(args)
+                        if not result:
+                            enable = False
+                            iftrigger = False
+                        else:
+                            iftrigger = True
+                elif name == 'elif':
+                    if ifstack:
+                        if ifstack[-1][0]:     # We only pay attention if outer "if" allows this
+                            if enable:         # If already true, we flip enable False
+                                enable = False
+                            elif not iftrigger:   # If False, but not triggered yet, we'll check expression
+                                result = self.evalexpr(args)
+                                if result:
+                                    enable  = True
+                                    iftrigger = True
+                    else:
+                        self.error(self.source,dirtokens[0].lineno,"Misplaced #elif")
+                        
+                elif name == 'else':
+                    if ifstack:
+                        if ifstack[-1][0]:
+                            if enable:
+                                enable = False
+                            elif not iftrigger:
+                                enable = True
+                                iftrigger = True
+                    else:
+                        self.error(self.source,dirtokens[0].lineno,"Misplaced #else")
+
+                elif name == 'endif':
+                    if ifstack:
+                        enable,iftrigger = ifstack.pop()
+                    else:
+                        self.error(self.source,dirtokens[0].lineno,"Misplaced #endif")
+                else:
+                    # Unknown preprocessor directive
+                    pass
+
+            else:
+                # Normal text
+                if enable:
+                    chunk.extend(x)
+
+        for tok in self.expand_macros(chunk):
+            yield tok
+        chunk = []
+
+    # ----------------------------------------------------------------------
+    # include()
+    #
+    # Implementation of file-inclusion
+    # ----------------------------------------------------------------------
+
+    def include(self,tokens):
+        # Try to extract the filename and then process an include file
+        if not tokens:
+            return
+        if tokens:
+            if tokens[0].value != '<' and tokens[0].type != self.t_STRING:
+                tokens = self.expand_macros(tokens)
+
+            if tokens[0].value == '<':
+                # Include <...>
+                i = 1
+                while i < len(tokens):
+                    if tokens[i].value == '>':
+                        break
+                    i += 1
+                else:
+                    print("Malformed #include <...>")
+                    return
+                filename = "".join([x.value for x in tokens[1:i]])
+                path = self.path + [""] + self.temp_path
+            elif tokens[0].type == self.t_STRING:
+                filename = tokens[0].value[1:-1]
+                path = self.temp_path + [""] + self.path
+            else:
+                print("Malformed #include statement")
+                return
+        for p in path:
+            iname = os.path.join(p,filename)
+            try:
+                data = open(iname,"r").read()
+                dname = os.path.dirname(iname)
+                if dname:
+                    self.temp_path.insert(0,dname)
+                for tok in self.parsegen(data,filename):
+                    yield tok
+                if dname:
+                    del self.temp_path[0]
+                break
+            except IOError:
+                pass
+        else:
+            print("Couldn't find '%s'" % filename)
+
+    # ----------------------------------------------------------------------
+    # define()
+    #
+    # Define a new macro
+    # ----------------------------------------------------------------------
+
+    def define(self,tokens):
+        if isinstance(tokens,(str,unicode)):
+            tokens = self.tokenize(tokens)
+
+        linetok = tokens
+        try:
+            name = linetok[0]
+            if len(linetok) > 1:
+                mtype = linetok[1]
+            else:
+                mtype = None
+            if not mtype:
+                m = Macro(name.value,[])
+                self.macros[name.value] = m
+            elif mtype.type in self.t_WS:
+                # A normal macro
+                m = Macro(name.value,self.tokenstrip(linetok[2:]))
+                self.macros[name.value] = m
+            elif mtype.value == '(':
+                # A macro with arguments
+                tokcount, args, positions = self.collect_args(linetok[1:])
+                variadic = False
+                for a in args:
+                    if variadic:
+                        print("No more arguments may follow a variadic argument")
+                        break
+                    astr = "".join([str(_i.value) for _i in a])
+                    if astr == "...":
+                        variadic = True
+                        a[0].type = self.t_ID
+                        a[0].value = '__VA_ARGS__'
+                        variadic = True
+                        del a[1:]
+                        continue
+                    elif astr[-3:] == "..." and a[0].type == self.t_ID:
+                        variadic = True
+                        del a[1:]
+                        # If, for some reason, "." is part of the identifier, strip off the name for the purposes
+                        # of macro expansion
+                        if a[0].value[-3:] == '...':
+                            a[0].value = a[0].value[:-3]
+                        continue
+                    if len(a) > 1 or a[0].type != self.t_ID:
+                        print("Invalid macro argument")
+                        break
+                else:
+                    mvalue = self.tokenstrip(linetok[1+tokcount:])
+                    i = 0
+                    while i < len(mvalue):
+                        if i+1 < len(mvalue):
+                            if mvalue[i].type in self.t_WS and mvalue[i+1].value == '##':
+                                del mvalue[i]
+                                continue
+                            elif mvalue[i].value == '##' and mvalue[i+1].type in self.t_WS:
+                                del mvalue[i+1]
+                        i += 1
+                    m = Macro(name.value,mvalue,[x[0].value for x in args],variadic)
+                    self.macro_prescan(m)
+                    self.macros[name.value] = m
+            else:
+                print("Bad macro definition")
+        except LookupError:
+            print("Bad macro definition")
+
+    # ----------------------------------------------------------------------
+    # undef()
+    #
+    # Undefine a macro
+    # ----------------------------------------------------------------------
+
+    def undef(self,tokens):
+        id = tokens[0].value
+        try:
+            del self.macros[id]
+        except LookupError:
+            pass
+
+    # ----------------------------------------------------------------------
+    # parse()
+    #
+    # Parse input text.
+    # ----------------------------------------------------------------------
+    def parse(self,input,source=None,ignore={}):
+        self.ignore = ignore
+        self.parser = self.parsegen(input,source)
+        
+    # ----------------------------------------------------------------------
+    # token()
+    #
+    # Method to return individual tokens
+    # ----------------------------------------------------------------------
+    def token(self):
+        try:
+            while True:
+                tok = next(self.parser)
+                if tok.type not in self.ignore: return tok
+        except StopIteration:
+            self.parser = None
+            return None
+
+if __name__ == '__main__':
+    import ply.lex as lex
+    lexer = lex.lex()
+
+    # Run a preprocessor
+    import sys
+    f = open(sys.argv[1])
+    input = f.read()
+
+    p = Preprocessor(lexer)
+    p.parse(input,sys.argv[1])
+    while True:
+        tok = p.token()
+        if not tok: break
+        print(p.source, tok)
+
+
+
+
+    
+
+
+
+
+
+

bin/ply/ctokens.py

@@ -0,0 +1,133 @@
+# ----------------------------------------------------------------------
+# ctokens.py
+#
+# Token specifications for symbols in ANSI C and C++.  This file is
+# meant to be used as a library in other tokenizers.
+# ----------------------------------------------------------------------
+
+# Reserved words
+
+tokens = [
+    # Literals (identifier, integer constant, float constant, string constant, char const)
+    'ID', 'TYPEID', 'ICONST', 'FCONST', 'SCONST', 'CCONST',
+
+    # Operators (+,-,*,/,%,|,&,~,^,<<,>>, ||, &&, !, <, <=, >, >=, ==, !=)
+    'PLUS', 'MINUS', 'TIMES', 'DIVIDE', 'MOD',
+    'OR', 'AND', 'NOT', 'XOR', 'LSHIFT', 'RSHIFT',
+    'LOR', 'LAND', 'LNOT',
+    'LT', 'LE', 'GT', 'GE', 'EQ', 'NE',
+    
+    # Assignment (=, *=, /=, %=, +=, -=, <<=, >>=, &=, ^=, |=)
+    'EQUALS', 'TIMESEQUAL', 'DIVEQUAL', 'MODEQUAL', 'PLUSEQUAL', 'MINUSEQUAL',
+    'LSHIFTEQUAL','RSHIFTEQUAL', 'ANDEQUAL', 'XOREQUAL', 'OREQUAL',
+
+    # Increment/decrement (++,--)
+    'PLUSPLUS', 'MINUSMINUS',
+
+    # Structure dereference (->)
+    'ARROW',
+
+    # Ternary operator (?)
+    'TERNARY',
+    
+    # Delimeters ( ) [ ] { } , . ; :
+    'LPAREN', 'RPAREN',
+    'LBRACKET', 'RBRACKET',
+    'LBRACE', 'RBRACE',
+    'COMMA', 'PERIOD', 'SEMI', 'COLON',
+
+    # Ellipsis (...)
+    'ELLIPSIS',
+]
+    
+# Operators
+t_PLUS             = r'\+'
+t_MINUS            = r'-'
+t_TIMES            = r'\*'
+t_DIVIDE           = r'/'
+t_MODULO           = r'%'
+t_OR               = r'\|'
+t_AND              = r'&'
+t_NOT              = r'~'
+t_XOR              = r'\^'
+t_LSHIFT           = r'<<'
+t_RSHIFT           = r'>>'
+t_LOR              = r'\|\|'
+t_LAND             = r'&&'
+t_LNOT             = r'!'
+t_LT               = r'<'
+t_GT               = r'>'
+t_LE               = r'<='
+t_GE               = r'>='
+t_EQ               = r'=='
+t_NE               = r'!='
+
+# Assignment operators
+
+t_EQUALS           = r'='
+t_TIMESEQUAL       = r'\*='
+t_DIVEQUAL         = r'/='
+t_MODEQUAL         = r'%='
+t_PLUSEQUAL        = r'\+='
+t_MINUSEQUAL       = r'-='
+t_LSHIFTEQUAL      = r'<<='
+t_RSHIFTEQUAL      = r'>>='
+t_ANDEQUAL         = r'&='
+t_OREQUAL          = r'\|='
+t_XOREQUAL         = r'^='
+
+# Increment/decrement
+t_INCREMENT        = r'\+\+'
+t_DECREMENT        = r'--'
+
+# ->
+t_ARROW            = r'->'
+
+# ?
+t_TERNARY          = r'\?'
+
+# Delimeters
+t_LPAREN           = r'\('
+t_RPAREN           = r'\)'
+t_LBRACKET         = r'\['
+t_RBRACKET         = r'\]'
+t_LBRACE           = r'\{'
+t_RBRACE           = r'\}'
+t_COMMA            = r','
+t_PERIOD           = r'\.'
+t_SEMI             = r';'
+t_COLON            = r':'
+t_ELLIPSIS         = r'\.\.\.'
+
+# Identifiers
+t_ID = r'[A-Za-z_][A-Za-z0-9_]*'
+
+# Integer literal
+t_INTEGER = r'\d+([uU]|[lL]|[uU][lL]|[lL][uU])?'
+
+# Floating literal
+t_FLOAT = r'((\d+)(\.\d+)(e(\+|-)?(\d+))? | (\d+)e(\+|-)?(\d+))([lL]|[fF])?'
+
+# String literal
+t_STRING = r'\"([^\\\n]|(\\.))*?\"'
+
+# Character constant 'c' or L'c'
+t_CHARACTER = r'(L)?\'([^\\\n]|(\\.))*?\''
+
+# Comment (C-Style)
+def t_COMMENT(t):
+    r'/\*(.|\n)*?\*/'
+    t.lexer.lineno += t.value.count('\n')
+    return t
+
+# Comment (C++-Style)
+def t_CPPCOMMENT(t):
+    r'//.*\n'
+    t.lexer.lineno += 1
+    return t
+
+
+    
+
+
+

bin/ripple/ledger/Args.py

@@ -0,0 +1,168 @@
+from __future__ import absolute_import, division, print_function, unicode_literals
+
+import argparse
+import importlib
+import os
+
+from ripple.ledger import LedgerNumber
+from ripple.util import File
+from ripple.util import Log
+from ripple.util import Range
+from ripple.util.Function import Function
+
+NAME = 'LedgerTool'
+VERSION = '0.1'
+
+_parser = argparse.ArgumentParser(
+    prog=NAME,
+    description='Retrieve and process Ripple ledgers.',
+    epilog=LedgerNumber.HELP,
+    )
+
+# Positional arguments.
+_parser.add_argument(
+    'command',
+    nargs='*',
+    help='Command to execute.'
+)
+
+# Flag arguments.
+_parser.add_argument(
+    '--binary',
+    action='store_true',
+    help='If true, searches are binary - by default linear search is used.',
+    )
+
+_parser.add_argument(
+    '--cache',
+    default='~/.local/share/ripple/ledger',
+    help='The cache directory.',
+    )
+
+_parser.add_argument(
+    '--complete',
+    action='store_true',
+    help='If set, only match complete ledgers.',
+    )
+
+_parser.add_argument(
+    '--condition', '-c',
+    help='The name of a condition function used to match ledgers.',
+    )
+
+_parser.add_argument(
+    '--config',
+    help='The rippled configuration file name.',
+    )
+
+_parser.add_argument(
+    '--display', '-d',
+    help='Specify a function to display ledgers.',
+    )
+
+_parser.add_argument(
+    '--full', '-f',
+    action='store_true',
+    help='If true, request full ledgers.',
+    )
+
+_parser.add_argument(
+    '--indent', '-i',
+    type=int,
+    default=2,
+    help='How many spaces to indent when display in JSON.',
+    )
+
+_parser.add_argument(
+    '--offline', '-o',
+    action='store_true',
+    help='If true, work entirely from cache, do not try to contact the server.',
+    )
+
+_parser.add_argument(
+    '--position', '-p',
+    choices=['all', 'first', 'last'],
+    default='last',
+    help='Select which ledgers to display.',
+    )
+
+_parser.add_argument(
+    '--rippled', '-r',
+    help='The filename of a rippled binary for retrieving ledgers.',
+    )
+
+_parser.add_argument(
+    '--server', '-s',
+    help='IP address of a rippled JSON server.',
+    )
+
+_parser.add_argument(
+    '--utc', '-u',
+    action='store_true',
+    help='If true, display times in UTC rather than local time.',
+    )
+
+_parser.add_argument(
+    '--version',
+    action='version',
+    version='%(prog)s ' + VERSION,
+    help='Print the current version of %(prog)s',
+    )
+
+_parser.add_argument(
+    '--verbose', '-v',
+    action='store_true',
+    help='If true, give status messages on stderr.',
+    )
+
+_parser.add_argument(
+    '--window', '-w',
+    type=int,
+    default=0,
+    help='How many ledgers to display around the matching ledger.',
+    )
+
+_parser.add_argument(
+    '--yes', '-y',
+    action='store_true',
+    help='If true, don\'t ask for confirmation on large commands.',
+)
+
+# Read the arguments from the command line.
+ARGS = _parser.parse_args()
+
+Log.VERBOSE = ARGS.verbose
+
+# Now remove any items that look like ledger numbers from the command line.
+_command = ARGS.command
+_parts = (ARGS.command, ARGS.ledgers) = ([], [])
+
+for c in _command:
+    _parts[Range.is_range(c, *LedgerNumber.LEDGERS)].append(c)
+
+ARGS.command = ARGS.command or ['print' if ARGS.ledgers else 'info']
+
+ARGS.cache = File.normalize(ARGS.cache)
+
+if not ARGS.ledgers:
+    if ARGS.condition:
+        Log.warn('--condition needs a range of ledgers')
+    if ARGS.display:
+        Log.warn('--display needs a range of ledgers')
+
+ARGS.condition = Function(
+    ARGS.condition or 'all_ledgers', 'ripple.ledger.conditions')
+ARGS.display = Function(
+    ARGS.display or 'ledger_number', 'ripple.ledger.displays')
+
+if ARGS.window < 0:
+    raise ValueError('Window cannot be negative: --window=%d' %
+                     ARGS.window)
+
+_loaders = bool(ARGS.server) + bool(ARGS.rippled)
+
+if not _loaders:
+    ARGS.rippled = 'rippled'
+
+elif _loaders > 1:
+    raise ValueError('At most one of --rippled and --server must be specified')

bin/ripple/ledger/LedgerNumber.py

@@ -0,0 +1,18 @@
+from __future__ import absolute_import, division, print_function, unicode_literals
+
+from ripple.util import Range
+
+FIRST_EVER = 32570
+
+LEDGERS = {
+    'closed': 'the most recently closed ledger',
+    'current': 'the current ledger',
+    'first': 'the first complete ledger on this server',
+    'last': 'the last complete ledger on this server',
+    'validated': 'the most recently validated ledger',
+    }
+
+HELP = """
+Ledgers are either represented by a number, or one of the special ledgers;
+""" + ',\n'.join('%s, %s' % (k, v) for k, v in sorted(LEDGERS.items())
+)

bin/ripple/ledger/PrettyPrint.py

@@ -0,0 +1,21 @@
+from __future__ import absolute_import, division, print_function, unicode_literals
+
+from ripple.ledger.Args import ARGS
+
+from functools import wraps
+import json
+
+def pretty_print(item):
+    return json.dumps(item,
+                      sort_keys=True,
+                      indent=ARGS.indent,
+                      separators=(',', ': '))
+
+def pretty(f):
+    """"A decorator on a function that makes its results pretty """
+    @wraps(f)
+    def wrapper(*args, **kwds):
+        result = list(f(*args, **kwds))
+        return pretty_print(result)
+
+    return wrapper

bin/ripple/ledger/RippledReader.py

@@ -0,0 +1,68 @@
+from __future__ import absolute_import, division, print_function, unicode_literals
+
+import json
+import os
+import subprocess
+
+from ripple.ledger.Args import ARGS
+from ripple.util import File
+from ripple.util import Log
+from ripple.util import Range
+
+_ERROR_CODE_REASON = {
+    62: 'No rippled server is running.',
+}
+
+_ERROR_TEXT = {
+    'lgrNotFound': 'The ledger you requested was not found.',
+    'noCurrent': 'The server has no current ledger.',
+    'noNetwork': 'The server did not respond to your request.',
+}
+
+_DEFAULT_ERROR_ = "Couldn't connect to server."
+
+class RippledReader(object):
+    def __init__(self):
+        fname = File.normalize(ARGS.rippled)
+        if not os.path.exists(fname):
+            raise Exception('No rippled found at %s.' % fname)
+        self.cmd = [fname]
+        if ARGS.config:
+            self.cmd.extend(['--conf', _normalize(ARGS.config)])
+        self.info = self._command('server_info')['info']
+        c = self.info.get('complete_ledgers')
+        if c == 'empty':
+            self.complete = []
+        else:
+            self.complete = sorted(Range.from_string(c))
+
+    def name_to_ledger_index(self, ledger_name, is_full=False):
+        return self.get_ledger(ledger_name, is_full)['ledger_index']
+
+    def get_ledger(self, name, is_full=False):
+        cmd = ['ledger', str(name)]
+        if is_full:
+            cmd.append('full')
+        response = self._command(*cmd)
+        result = response.get('ledger')
+        if result:
+            return result
+        error = response['error']
+        etext = _ERROR_TEXT.get(error)
+        if etext:
+            error = '%s (%s)' % (etext, error)
+        Log.fatal(_ERROR_TEXT.get(error, error))
+
+    def _command(self, *cmds):
+        cmd = self.cmd + list(cmds)
+        try:
+            data = subprocess.check_output(cmd, stderr=subprocess.PIPE)
+        except subprocess.CalledProcessError as e:
+            raise Exception(_ERROR_CODE_REASON.get(
+                e.returncode, _DEFAULT_ERROR_))
+
+        part = json.loads(data)
+        try:
+            return part['result']
+        except:
+            raise ValueError(part.get('error', 'unknown error'))

bin/ripple/ledger/SearchLedgers.py

@@ -0,0 +1,24 @@
+from __future__ import absolute_import, division, print_function, unicode_literals
+
+import sys
+
+from ripple.ledger.Args import ARGS
+from ripple.util import Log
+from ripple.util import Range
+from ripple.util import Search
+
+def search(server):
+    """Yields a stream of ledger numbers that match the given condition."""
+    condition = lambda number: ARGS.condition(server, number)
+    ledgers = server.ledgers
+    if ARGS.binary:
+        try:
+            position = Search.FIRST if ARGS.position == 'first' else Search.LAST
+            yield Search.binary_search(
+                ledgers[0], ledgers[-1], condition, position)
+        except:
+            Log.fatal('No ledgers matching condition "%s".' % condition,
+                      file=sys.stderr)
+    else:
+        for x in Search.linear_search(ledgers, condition):
+            yield x

bin/ripple/ledger/Server.py

@@ -0,0 +1,52 @@
+from __future__ import absolute_import, division, print_function, unicode_literals
+
+import json
+import os
+
+from ripple.ledger import RippledReader, ServerReader
+from ripple.ledger.Args import ARGS
+from ripple.util.FileCache import FileCache
+from ripple.util import Range
+
+class Server(object):
+    def __init__(self):
+        if ARGS.rippled:
+            reader = RippledReader.RippledReader()
+        else:
+            reader = ServerReader.ServerReader()
+
+        self.reader = reader
+        self.complete = reader.complete
+
+        names = {
+            'closed': reader.name_to_ledger_index('closed'),
+            'current': reader.name_to_ledger_index('current'),
+            'validated': reader.name_to_ledger_index('validated'),
+            'first': self.complete[0] if self.complete else None,
+            'last': self.complete[-1] if self.complete else None
+,
+        }
+        self.__dict__.update(names)
+        self.ledgers = sorted(Range.join_ranges(*ARGS.ledgers, **names))
+
+        def make_cache(is_full):
+            name = 'full' if is_full else 'summary'
+            filepath = os.path.join(ARGS.cache, name)
+            creator = lambda n: reader.get_ledger(n, is_full)
+            return FileCache(filepath, creator)
+        self._caches = [make_cache(False), make_cache(True)]
+
+    def info(self):
+        return self.reader.info
+
+    def cache(self, is_full):
+        return self._caches[is_full]
+
+    def get_ledger(self, number, is_full=False):
+        num = int(number)
+        save_in_cache = num in self.complete
+        can_create = (not ARGS.offline and
+                      self.complete and
+                      self.complete[0] <= num - 1)
+        cache = self.cache(is_full)
+        return cache.get_data(number, save_in_cache, can_create)

bin/ripple/ledger/ServerReader.py

@@ -0,0 +1,5 @@
+from __future__ import absolute_import, division, print_function, unicode_literals
+
+class ServerReader(object):
+    def __init__(self, server):
+        raise ValueError('Direct server connections are not yet implemented.')

bin/ripple/ledger/commands/Cache.py

@@ -0,0 +1,34 @@
+from __future__ import absolute_import, division, print_function, unicode_literals
+
+from ripple.ledger.Args import ARGS
+from ripple.ledger.PrettyPrint import pretty_print
+from ripple.util import Log
+from ripple.util import Range
+
+SAFE = True
+
+HELP = """cache
+return server_info"""
+
+def cache(server, clear=False):
+    cache = server.cache(ARGS.full)
+    name = ['summary', 'full'][ARGS.full]
+    files = cache.file_count()
+    if not files:
+        Log.error('No files in %s cache.' % name)
+
+    elif clear:
+        if not clear.strip() == 'clear':
+            raise Exception("Don't understand 'clear %s'." % clear)
+        if not ARGS.yes:
+            yes = raw_input('OK to clear %s cache? (y/N) ' % name)
+            if not yes.lower().startswith('y'):
+                Log.out('Cancelled.')
+                return
+        cache.clear(ARGS.full)
+        Log.out('%s cache cleared - %d file%s deleted.' %
+                (name.capitalize(), files, '' if files == 1 else 's'))
+
+    else:
+        caches = (int(c) for c in cache.cache_list())
+        Log.out(Range.to_string(caches))

bin/ripple/ledger/commands/Info.py

@@ -0,0 +1,21 @@
+from __future__ import absolute_import, division, print_function, unicode_literals
+
+from ripple.ledger.Args import ARGS
+from ripple.ledger.PrettyPrint import pretty_print
+from ripple.util import Log
+from ripple.util import Range
+
+SAFE = True
+
+HELP = 'info - return server_info'
+
+def info(server):
+    Log.out('first = ', server.first)
+    Log.out('last = ', server.last)
+    Log.out('closed =', server.closed)
+    Log.out('current =', server.current)
+    Log.out('validated =', server.validated)
+    Log.out('complete =', Range.to_string(server.complete))
+
+    if ARGS.full:
+        Log.out(pretty_print(server.info()))

bin/ripple/ledger/commands/Print.py

@@ -0,0 +1,16 @@
+from __future__ import absolute_import, division, print_function, unicode_literals
+
+from ripple.ledger.Args import ARGS
+from ripple.ledger import SearchLedgers
+
+import json
+
+SAFE = True
+
+HELP = """print
+
+Print the ledgers to stdout.  The default command."""
+
+def run_print(server):
+    for x in ARGS.display(server, SearchLedgers.search(server)):
+        print(x)

bin/ripple/ledger/conditions/__init__.py

@@ -0,0 +1,4 @@
+from __future__ import absolute_import, division, print_function, unicode_literals
+
+def all_ledgers(server, ledger_number):
+    return True

bin/ripple/ledger/displays/__init__.py

@@ -0,0 +1,91 @@
+from __future__ import absolute_import, division, print_function, unicode_literals
+
+from functools import wraps
+
+import jsonpath_rw
+
+from ripple.ledger.Args import ARGS
+from ripple.ledger.PrettyPrint import pretty_print
+from ripple.util import Dict
+from ripple.util import Log
+from ripple.util import Range
+from ripple.util.Decimal import Decimal
+
+TRANSACT_FIELDS = (
+    'accepted',
+    'close_time_human',
+    'closed',
+    'ledger_index',
+    'total_coins',
+    'transactions',
+)
+
+LEDGER_FIELDS = (
+    'accepted',
+    'accountState',
+    'close_time_human',
+    'closed',
+    'ledger_index',
+    'total_coins',
+    'transactions',
+)
+
+def _dict_filter(d, keys):
+    return dict((k, v) for (k, v) in d.items() if k in keys)
+
+def ledger_number(server, numbers):
+    yield Range.to_string(numbers)
+
+def display(f):
+    """A decorator for displays that just print JSON"""
+    @wraps(f)
+    def wrapper(server, numbers, *args, **kwds):
+        for number in numbers:
+            ledger = server.get_ledger(number, ARGS.full)
+            if ledger:
+                yield pretty_print(f(ledger, *args, **kwds))
+    return wrapper
+
+def json(f):
+    """A decorator for displays that print JSON, extracted by a path"""
+    @wraps(f)
+    def wrapper(server, numbers, path, *args, **kwds):
+        try:
+            path_expr = jsonpath_rw.parse(path)
+        except:
+            raise ValueError("Can't understand jsonpath '%s'." % path)
+
+        for number in numbers:
+            ledger = server.get_ledger(number, ARGS.full)
+            if ledger:
+                finds = path_expr.find(ledger)
+                yield pretty_print(f(finds, *args, **kwds))
+    return wrapper
+
+@display
+def ledger(ledger, full=False):
+    if ARGS.full:
+        if full:
+            return ledger
+        ledger = Dict.prune(ledger, 1, False)
+
+    return _dict_filter(ledger, LEDGER_FIELDS)
+
+@display
+def prune(ledger, level=1):
+    return Dict.prune(ledger, level, False)
+
+@display
+def transact(ledger):
+    return _dict_filter(ledger, TRANSACT_FIELDS)
+
+@json
+def extract(finds):
+    return dict((str(f.full_path), str(f.value)) for f in finds)
+
+@json
+def sum(finds):
+    d = Decimal()
+    for f in finds:
+        d.accumulate(f.value)
+    return [str(d), len(finds)]

bin/ripple/util/Cache.py

@@ -0,0 +1,40 @@
+from __future__ import absolute_import, division, print_function, unicode_literals
+
+from collections import defaultdict
+
+class Cache(object):
+    def __init__(self):
+        self._value_to_index = {}
+        self._index_to_value = []
+
+    def value_to_index(self, value, **kwds):
+        index = self._value_to_index.get(value, None)
+        if index is None:
+            index = len(self._index_to_value)
+            self._index_to_value.append((value, kwds))
+            self._value_to_index[value] = index
+        return index
+
+    def index_to_value(self, index):
+        return self._index_to_value[index]
+
+def NamedCache():
+    return defaultdict(Cache)
+
+def cache_by_key(d, keyfunc=None, exclude=None):
+    cache = defaultdict(Cache)
+    exclude = exclude or None
+    keyfunc = keyfunc or (lambda x: x)
+
+    def visit(item):
+        if isinstance(item, list):
+            for i, x in enumerate(item):
+                item[i] = visit(x)
+
+        elif isinstance(item, dict):
+            for k, v in item.items():
+                item[k] = visit(v)
+
+        return item
+
+    return cache

bin/ripple/util/CommandList.py

@@ -0,0 +1,77 @@
+from __future__ import absolute_import, division, print_function, unicode_literals
+
+# Code taken from github/rec/grit.
+
+import os
+import sys
+
+from collections import namedtuple
+
+from ripple.ledger.Args import ARGS
+from ripple.util import Log
+
+Command = namedtuple('Command', 'function help safe')
+
+def make_command(module):
+    name = module.__name__.split('.')[-1].lower()
+    return name, Command(getattr(module, name, None) or
+                         getattr(module, 'run_' + name),
+                         getattr(module, 'HELP'),
+                         getattr(module, 'SAFE', False))
+
+class CommandList(object):
+    def __init__(self, *args, **kwds):
+        self.registry = {}
+        self.register(*args, **kwds)
+
+    def register(self, *modules, **kwds):
+        for module in modules:
+            name, command = make_command(module)
+            self.registry[name] = command
+
+        for k, v in kwds.items():
+            if not isinstance(v, (list, tuple)):
+                v = [v]
+            self.register_one(k, *v)
+
+    def keys(self):
+        return self.registry.keys()
+
+    def register_one(self, name, function, help='', safe=False):
+        assert name not in self.registry
+        self.registry[name] = Command(function, help, safe)
+
+    def _get(self, command):
+        command = command.lower()
+        c = self.registry.get(command)
+        if c:
+            return command, c
+        commands = [c for c in self.registry if c.startswith(command)]
+        if len(commands) == 1:
+            command = commands[0]
+            return command, self.registry[command]
+        if not commands:
+            raise ValueError('No such command: %s.  Commands are %s.' %
+                             (command, ', '.join(sorted(self.registry))))
+        if len(commands) > 1:
+            raise ValueError('Command %s was ambiguous: %s.' %
+                             (command, ', '.join(commands)))
+
+    def get(self, command):
+        return self._get(command)[1]
+
+    def run(self, command, *args):
+        return self.get(command).function(*args)
+
+    def run_safe(self, command, *args):
+        name, cmd = self._get(command)
+        if not (ARGS.yes or cmd.safe):
+            confirm = raw_input('OK to execute "rl %s %s"? (y/N) ' %
+                                (name, ' '.join(args)))
+            if not confirm.lower().startswith('y'):
+                Log.error('Cancelled.')
+                return
+        cmd.function(*args)
+
+    def help(self, command):
+        return self.get(command).help()

bin/ripple/util/Decimal.py

@@ -0,0 +1,46 @@
+from __future__ import absolute_import, division, print_function, unicode_literals
+
+"""Fixed point numbers."""
+
+POSITIONS = 10
+POSITIONS_SHIFT = 10 ** POSITIONS
+
+class Decimal(object):
+    def __init__(self, desc='0'):
+        if isinstance(desc, int):
+            self.value = desc
+            return
+        if desc.startswith('-'):
+            sign = -1
+            desc = desc[1:]
+        else:
+            sign = 1
+        parts = desc.split('.')
+        if len(parts) == 1:
+            parts.append('0')
+        elif len(parts) > 2:
+            raise Exception('Too many decimals in "%s"' % desc)
+        number, decimal = parts
+        # Fix the number of positions.
+        decimal = (decimal + POSITIONS * '0')[:POSITIONS]
+        self.value = sign * int(number + decimal)
+
+    def accumulate(self, item):
+        if not isinstance(item, Decimal):
+            item = Decimal(item)
+        self.value += item.value
+
+    def __str__(self):
+        if self.value >= 0:
+            sign = ''
+            value = self.value
+        else:
+            sign = '-'
+            value = -self.value
+        number = value // POSITIONS_SHIFT
+        decimal = (value % POSITIONS_SHIFT) * POSITIONS_SHIFT
+
+        if decimal:
+            return '%s%s.%s' % (sign, number, str(decimal).rstrip('0'))
+        else:
+            return '%s%s' % (sign, number)

bin/ripple/util/Dict.py

@@ -0,0 +1,33 @@
+from __future__ import absolute_import, division, print_function, unicode_literals
+
+def count_all_subitems(x):
+    """Count the subitems of a Python object, including the object itself."""
+    if isinstance(x, list):
+        return 1 + sum(count_all_subitems(i) for i in x)
+    if isinstance(x, dict):
+        return 1 + sum(count_all_subitems(i) for i in x.itervalues())
+    return 1
+
+def prune(item, level, count_recursively=True):
+    def subitems(x):
+        i = count_all_subitems(x) - 1 if count_recursively else len(x)
+        return '1 subitem' if i == 1 else '%d subitems' % i
+
+    assert level >= 0
+    if not item:
+        return item
+
+    if isinstance(item, list):
+        if level:
+            return [prune(i, level - 1, count_recursively) for i in item]
+        else:
+            return '[list with %s]' % subitems(item)
+
+    if isinstance(item, dict):
+        if level:
+            return dict((k, prune(v, level - 1, count_recursively))
+                        for k, v in item.iteritems())
+        else:
+           return '{dict with %s}' % subitems(item)
+
+    return item

bin/ripple/util/File.py

@@ -0,0 +1,7 @@
+from __future__ import absolute_import, division, print_function, unicode_literals
+
+import os
+
+def normalize(f):
+    f = os.path.join(*f.split('/'))  # For Windows users.
+    return os.path.abspath(os.path.expanduser(f))

bin/ripple/util/FileCache.py

@@ -0,0 +1,56 @@
+from __future__ import absolute_import, division, print_function, unicode_literals
+
+import gzip
+import json
+import os
+
+_NONE = object()
+
+class FileCache(object):
+    """A two-level cache, which stores expensive results in memory and on disk.
+    """
+    def __init__(self, cache_directory, creator, open=gzip.open, suffix='.gz'):
+        self.cache_directory = cache_directory
+        self.creator = creator
+        self.open = open
+        self.suffix = suffix
+        self.cached_data = {}
+        if not os.path.exists(self.cache_directory):
+            os.makedirs(self.cache_directory)
+
+    def get_file_data(self, name):
+        if os.path.exists(filename):
+            return json.load(self.open(filename))
+
+        result = self.creator(name)
+        return result
+
+    def get_data(self, name, save_in_cache, can_create, default=None):
+        name = str(name)
+        result = self.cached_data.get(name, _NONE)
+        if result is _NONE:
+            filename = os.path.join(self.cache_directory, name) + self.suffix
+            if os.path.exists(filename):
+                result = json.load(self.open(filename)) or _NONE
+            if result is _NONE and can_create:
+                result = self.creator(name)
+                if save_in_cache:
+                    json.dump(result, self.open(filename, 'w'))
+        return default if result is _NONE else result
+
+    def _files(self):
+        return os.listdir(self.cache_directory)
+
+    def cache_list(self):
+        for f in self._files():
+            if f.endswith(self.suffix):
+                yield f[:-len(self.suffix)]
+
+    def file_count(self):
+        return len(self._files())
+
+    def clear(self):
+        """Clears both local files and memory."""
+        self.cached_data = {}
+        for f in self._files():
+            os.remove(os.path.join(self.cache_directory, f))

bin/ripple/util/Function.py

@@ -0,0 +1,75 @@
+from __future__ import absolute_import, division, print_function, unicode_literals
+
+"""A function that can be specified at the command line, with an argument."""
+
+import importlib
+import re
+import tokenize
+
+from StringIO import StringIO
+
+MATCHER = re.compile(r'([\w.]+)(.*)')
+
+REMAPPINGS = {
+    'false': False,
+    'true': True,
+    'null': None,
+    'False': False,
+    'True': True,
+    'None': None,
+}
+
+def eval_arguments(args):
+    tokens = tokenize.generate_tokens(StringIO(args or '()').readline)
+    def remap():
+        for type, name, _, _, _ in tokens:
+            if type == tokenize.NAME and name not in REMAPPINGS:
+                yield tokenize.STRING, '"%s"' % name
+            else:
+                yield type, name
+    untok = tokenize.untokenize(remap())
+    if untok[1:-1].strip():
+        untok = untok[:-1] + ',)'  # Force a tuple.
+    return eval(untok, REMAPPINGS)
+
+class Function(object):
+    def __init__(self, desc='', default_path=''):
+        self.desc = desc.strip()
+        if not self.desc:
+            # Make an empty function that does nothing.
+            self.args = ()
+            self.function = lambda *args, **kwds: None
+            return
+
+        m = MATCHER.match(desc)
+        if not m:
+            raise ValueError('"%s" is not a function' % desc)
+        self.function, self.args = (g.strip() for g in m.groups())
+        self.args = eval_arguments(self.args)
+
+        if '.' not in self.function:
+            if default_path and not default_path.endswith('.'):
+                default_path += '.'
+            self.function = default_path + self.function
+        p, m = self.function.rsplit('.', 1)
+        try:
+            mod = importlib.import_module(p)
+        except:
+            raise ValueError('Can\'t find Python module "%s"' % p)
+
+        try:
+            self.function = getattr(mod, m)
+        except:
+            raise ValueError('No function "%s" in module "%s"' % (m, p))
+
+    def __str__(self):
+        return self.desc
+
+    def __call__(self, *args, **kwds):
+        return self.function(*(args + self.args), **kwds)
+
+    def __eq__(self, other):
+        return self.function == other.function and self.args == other.args
+
+    def __ne__(self, other):
+        return not (self == other)

bin/ripple/util/Log.py

@@ -0,0 +1,21 @@
+from __future__ import absolute_import, division, print_function, unicode_literals
+
+import sys
+
+VERBOSE = False
+
+def out(*args, **kwds):
+    kwds.get('print', print)(*args, file=sys.stdout, **kwds)
+
+def info(*args, **kwds):
+    if VERBOSE:
+        out(*args, **kwds)
+
+def warn(*args, **kwds):
+    out('WARNING:', *args, **kwds)
+
+def error(*args, **kwds):
+    out('ERROR:', *args, **kwds)
+
+def fatal(*args, **kwds):
+    raise Exception('FATAL: ' + ' '.join(str(a) for a in args))

bin/ripple/util/Range.py

@@ -0,0 +1,53 @@
+from __future__ import absolute_import, division, print_function, unicode_literals
+
+"""
+Convert a discontiguous range of integers to and from a human-friendly form.
+
+Real world example is the server_info.complete_ledgers:
+  8252899-8403772,8403824,8403827-8403830,8403834-8403876
+
+"""
+
+def from_string(desc, **aliases):
+    if not desc:
+        return []
+    result = set()
+    for d in desc.split(','):
+        nums = [int(aliases.get(x) or x) for x in d.split('-')]
+        if len(nums) == 1:
+            result.add(nums[0])
+        elif len(nums) == 2:
+            result.update(range(nums[0], nums[1] + 1))
+    return result
+
+def to_string(r):
+    groups = []
+    next_group = []
+    for i, x in enumerate(sorted(r)):
+        if next_group and (x - next_group[-1]) > 1:
+            groups.append(next_group)
+            next_group = []
+        next_group.append(x)
+    if next_group:
+        groups.append(next_group)
+
+    def display(g):
+        if len(g) == 1:
+            return str(g[0])
+        else:
+            return '%s-%s' % (g[0], g[-1])
+
+    return ','.join(display(g) for g in groups)
+
+def is_range(desc, *names):
+    try:
+        from_string(desc, **dict((n, 1) for n in names))
+        return True;
+    except ValueError:
+        return False
+
+def join_ranges(*ranges, **aliases):
+    result = set()
+    for r in ranges:
+        result.update(from_string(r, **aliases))
+    return result

bin/ripple/util/Search.py

@@ -0,0 +1,46 @@
+from __future__ import absolute_import, division, print_function, unicode_literals
+
+FIRST, LAST = range(2)
+
+def binary_search(begin, end, condition, location=FIRST):
+    """Search for an i in the interval [begin, end] where condition(i) is true.
+       If location is FIRST, return the first such i.
+       If location is LAST, return the last such i.
+       If there is no such i, then throw an exception.
+    """
+    b = condition(begin)
+    e = condition(end)
+    if b and e:
+        return begin if location == FIRST else end
+
+    if not (b or e):
+        raise ValueError('%d/%d' % (begin, end))
+
+    if b and location is FIRST:
+        return begin
+
+    if e and location is LAST:
+        return end
+
+    width = end - begin + 1
+    if width == 1:
+        if not b:
+            raise ValueError('%d/%d' % (begin, end))
+        return begin
+    if width == 2:
+        return begin if b else end
+
+    mid = (begin + end) // 2
+    m = condition(mid)
+
+    if m == b:
+        return binary_search(mid, end, condition, location)
+    else:
+        return binary_search(begin, mid, condition, location)
+
+def linear_search(items, condition):
+    """Yields each i in the interval [begin, end] where condition(i) is true.
+    """
+    for i in items:
+        if condition(i):
+            yield i

bin/ripple/util/Time.py

@@ -0,0 +1,21 @@
+from __future__ import absolute_import, division, print_function, unicode_literals
+
+import datetime
+
+# Format for human-readable dates in rippled
+_DATE_FORMAT = '%Y-%b-%d'
+_TIME_FORMAT = '%H:%M:%S'
+_DATETIME_FORMAT = '%s %s' % (_DATE_FORMAT, _TIME_FORMAT)
+
+_FORMATS = _DATE_FORMAT, _TIME_FORMAT, _DATETIME_FORMAT
+
+def parse_datetime(desc):
+    for fmt in _FORMATS:
+        try:
+            return datetime.date.strptime(desc, fmt)
+        except:
+            pass
+    raise ValueError("Can't understand date '%s'." % date)
+
+def format_datetime(dt):
+    return dt.strftime(_DATETIME_FORMAT)

bin/ripple/util/test_Cache.py

@@ -0,0 +1,12 @@
+from __future__ import absolute_import, division, print_function, unicode_literals
+
+from ripple.util.Cache import NamedCache
+
+from unittest import TestCase
+
+class test_Cache(TestCase):
+    def setUp(self):
+        self.cache = NamedCache()
+
+    def test_trivial(self):
+        pass

bin/ripple/util/test_Decimal.py

@@ -0,0 +1,20 @@
+from __future__ import absolute_import, division, print_function, unicode_literals
+
+from ripple.util.Decimal import Decimal
+
+from unittest import TestCase
+
+class test_Decimal(TestCase):
+    def test_construct(self):
+        self.assertEquals(str(Decimal('')), '0')
+        self.assertEquals(str(Decimal('0')), '0')
+        self.assertEquals(str(Decimal('0.2')), '0.2')
+        self.assertEquals(str(Decimal('-0.2')), '-0.2')
+        self.assertEquals(str(Decimal('3.1416')), '3.1416')
+
+    def test_accumulate(self):
+        d = Decimal()
+        d.accumulate('0.5')
+        d.accumulate('3.1416')
+        d.accumulate('-23.34234')
+        self.assertEquals(str(d), '-19.70074')

bin/ripple/util/test_Dict.py

@@ -0,0 +1,56 @@
+from __future__ import absolute_import, division, print_function, unicode_literals
+
+from ripple.util import Dict
+
+from unittest import TestCase
+
+class test_Dict(TestCase):
+    def test_count_all_subitems(self):
+        self.assertEquals(Dict.count_all_subitems({}), 1)
+        self.assertEquals(Dict.count_all_subitems({'a': {}}), 2)
+        self.assertEquals(Dict.count_all_subitems([1]), 2)
+        self.assertEquals(Dict.count_all_subitems([1, 2]), 3)
+        self.assertEquals(Dict.count_all_subitems([1, {2: 3}]), 4)
+        self.assertEquals(Dict.count_all_subitems([1, {2: [3]}]), 5)
+        self.assertEquals(Dict.count_all_subitems([1, {2: [3, 4]}]), 6)
+
+    def test_prune(self):
+        self.assertEquals(Dict.prune({}, 0), {})
+        self.assertEquals(Dict.prune({}, 1), {})
+
+        self.assertEquals(Dict.prune({1: 2}, 0), '{dict with 1 subitem}')
+        self.assertEquals(Dict.prune({1: 2}, 1), {1: 2})
+        self.assertEquals(Dict.prune({1: 2}, 2), {1: 2})
+
+        self.assertEquals(Dict.prune([1, 2, 3], 0), '[list with 3 subitems]')
+        self.assertEquals(Dict.prune([1, 2, 3], 1), [1, 2, 3])
+
+        self.assertEquals(Dict.prune([{1: [2, 3]}], 0),
+                          '[list with 4 subitems]')
+        self.assertEquals(Dict.prune([{1: [2, 3]}], 1),
+                          ['{dict with 3 subitems}'])
+        self.assertEquals(Dict.prune([{1: [2, 3]}], 2),
+                          [{1: u'[list with 2 subitems]'}])
+        self.assertEquals(Dict.prune([{1: [2, 3]}], 3),
+                          [{1: [2, 3]}])
+
+    def test_prune_nosub(self):
+        self.assertEquals(Dict.prune({}, 0, False), {})
+        self.assertEquals(Dict.prune({}, 1, False), {})
+
+        self.assertEquals(Dict.prune({1: 2}, 0, False), '{dict with 1 subitem}')
+        self.assertEquals(Dict.prune({1: 2}, 1, False), {1: 2})
+        self.assertEquals(Dict.prune({1: 2}, 2, False), {1: 2})
+
+        self.assertEquals(Dict.prune([1, 2, 3], 0, False),
+                          '[list with 3 subitems]')
+        self.assertEquals(Dict.prune([1, 2, 3], 1, False), [1, 2, 3])
+
+        self.assertEquals(Dict.prune([{1: [2, 3]}], 0, False),
+                          '[list with 1 subitem]')
+        self.assertEquals(Dict.prune([{1: [2, 3]}], 1, False),
+                          ['{dict with 1 subitem}'])
+        self.assertEquals(Dict.prune([{1: [2, 3]}], 2, False),
+                          [{1: u'[list with 2 subitems]'}])
+        self.assertEquals(Dict.prune([{1: [2, 3]}], 3, False),
+                          [{1: [2, 3]}])

bin/ripple/util/test_Function.py

@@ -0,0 +1,37 @@
+from __future__ import absolute_import, division, print_function, unicode_literals
+
+from ripple.util.Function import Function, MATCHER
+
+from unittest import TestCase
+
+def FN(*args, **kwds):
+    return args, kwds
+
+class test_Function(TestCase):
+    def match_test(self, item, *results):
+        self.assertEquals(MATCHER.match(item).groups(), results)
+
+    def test_simple(self):
+        self.match_test('function', 'function', '')
+        self.match_test('f(x)', 'f', '(x)')
+
+    def test_empty_function(self):
+        self.assertEquals(Function()(), None)
+
+    def test_empty_args(self):
+        f = Function('ripple.util.test_Function.FN()')
+        self.assertEquals(f(), ((), {}))
+
+    def test_function(self):
+        f = Function('ripple.util.test_Function.FN(True, {1: 2}, None)')
+        self.assertEquals(f(), ((True, {1: 2}, None), {}))
+        self.assertEquals(f('hello', foo='bar'),
+                          (('hello', True, {1: 2}, None), {'foo':'bar'}))
+        self.assertEquals(
+            f, Function('ripple.util.test_Function.FN(true, {1: 2}, null)'))
+
+    def test_quoting(self):
+        f = Function('ripple.util.test_Function.FN(testing)')
+        self.assertEquals(f(), (('testing',), {}))
+        f = Function('ripple.util.test_Function.FN(testing, true, false, null)')
+        self.assertEquals(f(), (('testing', True, False, None), {}))

bin/ripple/util/test_Range.py

@@ -0,0 +1,28 @@
+from __future__ import absolute_import, division, print_function, unicode_literals
+
+from ripple.util import Range
+
+from unittest import TestCase
+
+class test_Range(TestCase):
+    def round_trip(self, s, *items):
+        self.assertEquals(Range.from_string(s), set(items))
+        self.assertEquals(Range.to_string(items), s)
+
+    def test_complete(self):
+        self.round_trip('10,19', 10, 19)
+        self.round_trip('10', 10)
+        self.round_trip('10-12', 10, 11, 12)
+        self.round_trip('10,19,42-45', 10, 19, 42, 43, 44, 45)
+
+    def test_names(self):
+        self.assertEquals(
+            Range.from_string('first,last,current', first=1, last=3, current=5),
+            set([1, 3, 5]))
+
+    def test_is_range(self):
+        self.assertTrue(Range.is_range(''))
+        self.assertTrue(Range.is_range('10'))
+        self.assertTrue(Range.is_range('10,12'))
+        self.assertFalse(Range.is_range('10,12,fred'))
+        self.assertTrue(Range.is_range('10,12,fred', 'fred'))

bin/ripple/util/test_Search.py

@@ -0,0 +1,44 @@
+from __future__ import absolute_import, division, print_function, unicode_literals
+
+from ripple.util.Search import binary_search, linear_search, FIRST, LAST
+
+from unittest import TestCase
+
+class test_Search(TestCase):
+    def condition(self, i):
+        return 10 <= i < 15;
+
+    def test_linear_full(self):
+        self.assertEquals(list(linear_search(range(21), self.condition)),
+                          [10, 11, 12, 13, 14])
+
+    def test_linear_partial(self):
+        self.assertEquals(list(linear_search(range(8, 14), self.condition)),
+                          [10, 11, 12, 13])
+        self.assertEquals(list(linear_search(range(11, 14), self.condition)),
+                          [11, 12, 13])
+        self.assertEquals(list(linear_search(range(12, 18), self.condition)),
+                          [12, 13, 14])
+
+    def test_linear_empty(self):
+        self.assertEquals(list(linear_search(range(1, 4), self.condition)), [])
+
+    def test_binary_first(self):
+        self.assertEquals(binary_search(0, 14, self.condition, FIRST), 10)
+        self.assertEquals(binary_search(10, 19, self.condition, FIRST), 10)
+        self.assertEquals(binary_search(14, 14, self.condition, FIRST), 14)
+        self.assertEquals(binary_search(14, 15, self.condition, FIRST), 14)
+        self.assertEquals(binary_search(13, 15, self.condition, FIRST), 13)
+
+    def test_binary_last(self):
+        self.assertEquals(binary_search(10, 20, self.condition, LAST), 14)
+        self.assertEquals(binary_search(0, 14, self.condition, LAST), 14)
+        self.assertEquals(binary_search(14, 14, self.condition, LAST), 14)
+        self.assertEquals(binary_search(14, 15, self.condition, LAST), 14)
+        self.assertEquals(binary_search(13, 15, self.condition, LAST), 14)
+
+    def test_binary_throws(self):
+        self.assertRaises(
+            ValueError, binary_search, 0, 20, self.condition, LAST)
+        self.assertRaises(
+            ValueError, binary_search, 0, 20, self.condition, FIRST)

bin/six.py

@@ -0,0 +1,747 @@
+"""Utilities for writing code that runs on Python 2 and 3"""
+
+# Copyright (c) 2010-2014 Benjamin Peterson
+#
+# 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.
+
+import functools
+import operator
+import sys
+import types
+
+__author__ = "Benjamin Peterson <benjamin@python.org>"
+__version__ = "1.7.3"
+
+
+# Useful for very coarse version differentiation.
+PY2 = sys.version_info[0] == 2
+PY3 = sys.version_info[0] == 3
+
+if PY3:
+    string_types = str,
+    integer_types = int,
+    class_types = type,
+    text_type = str
+    binary_type = bytes
+
+    MAXSIZE = sys.maxsize
+else:
+    string_types = basestring,
+    integer_types = (int, long)
+    class_types = (type, types.ClassType)
+    text_type = unicode
+    binary_type = str
+
+    if sys.platform.startswith("java"):
+        # Jython always uses 32 bits.
+        MAXSIZE = int((1 << 31) - 1)
+    else:
+        # It's possible to have sizeof(long) != sizeof(Py_ssize_t).
+        class X(object):
+            def __len__(self):
+                return 1 << 31
+        try:
+            len(X())
+        except OverflowError:
+            # 32-bit
+            MAXSIZE = int((1 << 31) - 1)
+        else:
+            # 64-bit
+            MAXSIZE = int((1 << 63) - 1)
+        del X
+
+
+def _add_doc(func, doc):
+    """Add documentation to a function."""
+    func.__doc__ = doc
+
+
+def _import_module(name):
+    """Import module, returning the module after the last dot."""
+    __import__(name)
+    return sys.modules[name]
+
+
+class _LazyDescr(object):
+
+    def __init__(self, name):
+        self.name = name
+
+    def __get__(self, obj, tp):
+        result = self._resolve()
+        setattr(obj, self.name, result) # Invokes __set__.
+        # This is a bit ugly, but it avoids running this again.
+        delattr(obj.__class__, self.name)
+        return result
+
+
+class MovedModule(_LazyDescr):
+
+    def __init__(self, name, old, new=None):
+        super(MovedModule, self).__init__(name)
+        if PY3:
+            if new is None:
+                new = name
+            self.mod = new
+        else:
+            self.mod = old
+
+    def _resolve(self):
+        return _import_module(self.mod)
+
+    def __getattr__(self, attr):
+        _module = self._resolve()
+        value = getattr(_module, attr)
+        setattr(self, attr, value)
+        return value
+
+
+class _LazyModule(types.ModuleType):
+
+    def __init__(self, name):
+        super(_LazyModule, self).__init__(name)
+        self.__doc__ = self.__class__.__doc__
+
+    def __dir__(self):
+        attrs = ["__doc__", "__name__"]
+        attrs += [attr.name for attr in self._moved_attributes]
+        return attrs
+
+    # Subclasses should override this
+    _moved_attributes = []
+
+
+class MovedAttribute(_LazyDescr):
+
+    def __init__(self, name, old_mod, new_mod, old_attr=None, new_attr=None):
+        super(MovedAttribute, self).__init__(name)
+        if PY3:
+            if new_mod is None:
+                new_mod = name
+            self.mod = new_mod
+            if new_attr is None:
+                if old_attr is None:
+                    new_attr = name
+                else:
+                    new_attr = old_attr
+            self.attr = new_attr
+        else:
+            self.mod = old_mod
+            if old_attr is None:
+                old_attr = name
+            self.attr = old_attr
+
+    def _resolve(self):
+        module = _import_module(self.mod)
+        return getattr(module, self.attr)
+
+
+class _SixMetaPathImporter(object):
+    """
+    A meta path importer to import six.moves and its submodules.
+
+    This class implements a PEP302 finder and loader. It should be compatible
+    with Python 2.5 and all existing versions of Python3
+    """
+    def __init__(self, six_module_name):
+        self.name = six_module_name
+        self.known_modules = {}
+
+    def _add_module(self, mod, *fullnames):
+        for fullname in fullnames:
+            self.known_modules[self.name + "." + fullname] = mod
+
+    def _get_module(self, fullname):
+        return self.known_modules[self.name + "." + fullname]
+
+    def find_module(self, fullname, path=None):
+        if fullname in self.known_modules:
+            return self
+        return None
+
+    def __get_module(self, fullname):
+        try:
+            return self.known_modules[fullname]
+        except KeyError:
+            raise ImportError("This loader does not know module " + fullname)
+
+    def load_module(self, fullname):
+        try:
+            # in case of a reload
+            return sys.modules[fullname]
+        except KeyError:
+            pass
+        mod = self.__get_module(fullname)
+        if isinstance(mod, MovedModule):
+            mod = mod._resolve()
+        else:
+            mod.__loader__ = self
+        sys.modules[fullname] = mod
+        return mod
+
+    def is_package(self, fullname):
+        """
+        Return true, if the named module is a package.
+
+        We need this method to get correct spec objects with
+        Python 3.4 (see PEP451)
+        """
+        return hasattr(self.__get_module(fullname), "__path__")
+
+    def get_code(self, fullname):
+        """Return None
+
+        Required, if is_package is implemented"""
+        self.__get_module(fullname)  # eventually raises ImportError
+        return None
+    get_source = get_code  # same as get_code
+
+_importer = _SixMetaPathImporter(__name__)
+
+
+class _MovedItems(_LazyModule):
+    """Lazy loading of moved objects"""
+    __path__ = []  # mark as package
+
+
+_moved_attributes = [
+    MovedAttribute("cStringIO", "cStringIO", "io", "StringIO"),
+    MovedAttribute("filter", "itertools", "builtins", "ifilter", "filter"),
+    MovedAttribute("filterfalse", "itertools", "itertools", "ifilterfalse", "filterfalse"),
+    MovedAttribute("input", "__builtin__", "builtins", "raw_input", "input"),
+    MovedAttribute("map", "itertools", "builtins", "imap", "map"),
+    MovedAttribute("range", "__builtin__", "builtins", "xrange", "range"),
+    MovedAttribute("reload_module", "__builtin__", "imp", "reload"),
+    MovedAttribute("reduce", "__builtin__", "functools"),
+    MovedAttribute("StringIO", "StringIO", "io"),
+    MovedAttribute("UserDict", "UserDict", "collections"),
+    MovedAttribute("UserList", "UserList", "collections"),
+    MovedAttribute("UserString", "UserString", "collections"),
+    MovedAttribute("xrange", "__builtin__", "builtins", "xrange", "range"),
+    MovedAttribute("zip", "itertools", "builtins", "izip", "zip"),
+    MovedAttribute("zip_longest", "itertools", "itertools", "izip_longest", "zip_longest"),
+
+    MovedModule("builtins", "__builtin__"),
+    MovedModule("configparser", "ConfigParser"),
+    MovedModule("copyreg", "copy_reg"),
+    MovedModule("dbm_gnu", "gdbm", "dbm.gnu"),
+    MovedModule("_dummy_thread", "dummy_thread", "_dummy_thread"),
+    MovedModule("http_cookiejar", "cookielib", "http.cookiejar"),
+    MovedModule("http_cookies", "Cookie", "http.cookies"),
+    MovedModule("html_entities", "htmlentitydefs", "html.entities"),
+    MovedModule("html_parser", "HTMLParser", "html.parser"),
+    MovedModule("http_client", "httplib", "http.client"),
+    MovedModule("email_mime_multipart", "email.MIMEMultipart", "email.mime.multipart"),
+    MovedModule("email_mime_text", "email.MIMEText", "email.mime.text"),
+    MovedModule("email_mime_base", "email.MIMEBase", "email.mime.base"),
+    MovedModule("BaseHTTPServer", "BaseHTTPServer", "http.server"),
+    MovedModule("CGIHTTPServer", "CGIHTTPServer", "http.server"),
+    MovedModule("SimpleHTTPServer", "SimpleHTTPServer", "http.server"),
+    MovedModule("cPickle", "cPickle", "pickle"),
+    MovedModule("queue", "Queue"),
+    MovedModule("reprlib", "repr"),
+    MovedModule("socketserver", "SocketServer"),
+    MovedModule("_thread", "thread", "_thread"),
+    MovedModule("tkinter", "Tkinter"),
+    MovedModule("tkinter_dialog", "Dialog", "tkinter.dialog"),
+    MovedModule("tkinter_filedialog", "FileDialog", "tkinter.filedialog"),
+    MovedModule("tkinter_scrolledtext", "ScrolledText", "tkinter.scrolledtext"),
+    MovedModule("tkinter_simpledialog", "SimpleDialog", "tkinter.simpledialog"),
+    MovedModule("tkinter_tix", "Tix", "tkinter.tix"),
+    MovedModule("tkinter_ttk", "ttk", "tkinter.ttk"),
+    MovedModule("tkinter_constants", "Tkconstants", "tkinter.constants"),
+    MovedModule("tkinter_dnd", "Tkdnd", "tkinter.dnd"),
+    MovedModule("tkinter_colorchooser", "tkColorChooser",
+                "tkinter.colorchooser"),
+    MovedModule("tkinter_commondialog", "tkCommonDialog",
+                "tkinter.commondialog"),
+    MovedModule("tkinter_tkfiledialog", "tkFileDialog", "tkinter.filedialog"),
+    MovedModule("tkinter_font", "tkFont", "tkinter.font"),
+    MovedModule("tkinter_messagebox", "tkMessageBox", "tkinter.messagebox"),
+    MovedModule("tkinter_tksimpledialog", "tkSimpleDialog",
+                "tkinter.simpledialog"),
+    MovedModule("urllib_parse", __name__ + ".moves.urllib_parse", "urllib.parse"),
+    MovedModule("urllib_error", __name__ + ".moves.urllib_error", "urllib.error"),
+    MovedModule("urllib", __name__ + ".moves.urllib", __name__ + ".moves.urllib"),
+    MovedModule("urllib_robotparser", "robotparser", "urllib.robotparser"),
+    MovedModule("xmlrpc_client", "xmlrpclib", "xmlrpc.client"),
+    MovedModule("xmlrpc_server", "SimpleXMLRPCServer", "xmlrpc.server"),
+    MovedModule("winreg", "_winreg"),
+]
+for attr in _moved_attributes:
+    setattr(_MovedItems, attr.name, attr)
+    if isinstance(attr, MovedModule):
+        _importer._add_module(attr, "moves." + attr.name)
+del attr
+
+_MovedItems._moved_attributes = _moved_attributes
+
+moves = _MovedItems(__name__ + ".moves")
+_importer._add_module(moves, "moves")
+
+
+class Module_six_moves_urllib_parse(_LazyModule):
+    """Lazy loading of moved objects in six.moves.urllib_parse"""
+
+
+_urllib_parse_moved_attributes = [
+    MovedAttribute("ParseResult", "urlparse", "urllib.parse"),
+    MovedAttribute("SplitResult", "urlparse", "urllib.parse"),
+    MovedAttribute("parse_qs", "urlparse", "urllib.parse"),
+    MovedAttribute("parse_qsl", "urlparse", "urllib.parse"),
+    MovedAttribute("urldefrag", "urlparse", "urllib.parse"),
+    MovedAttribute("urljoin", "urlparse", "urllib.parse"),
+    MovedAttribute("urlparse", "urlparse", "urllib.parse"),
+    MovedAttribute("urlsplit", "urlparse", "urllib.parse"),
+    MovedAttribute("urlunparse", "urlparse", "urllib.parse"),
+    MovedAttribute("urlunsplit", "urlparse", "urllib.parse"),
+    MovedAttribute("quote", "urllib", "urllib.parse"),
+    MovedAttribute("quote_plus", "urllib", "urllib.parse"),
+    MovedAttribute("unquote", "urllib", "urllib.parse"),
+    MovedAttribute("unquote_plus", "urllib", "urllib.parse"),
+    MovedAttribute("urlencode", "urllib", "urllib.parse"),
+    MovedAttribute("splitquery", "urllib", "urllib.parse"),
+]
+for attr in _urllib_parse_moved_attributes:
+    setattr(Module_six_moves_urllib_parse, attr.name, attr)
+del attr
+
+Module_six_moves_urllib_parse._moved_attributes = _urllib_parse_moved_attributes
+
+_importer._add_module(Module_six_moves_urllib_parse(__name__ + ".moves.urllib_parse"),
+                      "moves.urllib_parse", "moves.urllib.parse")
+
+
+class Module_six_moves_urllib_error(_LazyModule):
+    """Lazy loading of moved objects in six.moves.urllib_error"""
+
+
+_urllib_error_moved_attributes = [
+    MovedAttribute("URLError", "urllib2", "urllib.error"),
+    MovedAttribute("HTTPError", "urllib2", "urllib.error"),
+    MovedAttribute("ContentTooShortError", "urllib", "urllib.error"),
+]
+for attr in _urllib_error_moved_attributes:
+    setattr(Module_six_moves_urllib_error, attr.name, attr)
+del attr
+
+Module_six_moves_urllib_error._moved_attributes = _urllib_error_moved_attributes
+
+_importer._add_module(Module_six_moves_urllib_error(__name__ + ".moves.urllib.error"),
+                      "moves.urllib_error", "moves.urllib.error")
+
+
+class Module_six_moves_urllib_request(_LazyModule):
+    """Lazy loading of moved objects in six.moves.urllib_request"""
+
+
+_urllib_request_moved_attributes = [
+    MovedAttribute("urlopen", "urllib2", "urllib.request"),
+    MovedAttribute("install_opener", "urllib2", "urllib.request"),
+    MovedAttribute("build_opener", "urllib2", "urllib.request"),
+    MovedAttribute("pathname2url", "urllib", "urllib.request"),
+    MovedAttribute("url2pathname", "urllib", "urllib.request"),
+    MovedAttribute("getproxies", "urllib", "urllib.request"),
+    MovedAttribute("Request", "urllib2", "urllib.request"),
+    MovedAttribute("OpenerDirector", "urllib2", "urllib.request"),
+    MovedAttribute("HTTPDefaultErrorHandler", "urllib2", "urllib.request"),
+    MovedAttribute("HTTPRedirectHandler", "urllib2", "urllib.request"),
+    MovedAttribute("HTTPCookieProcessor", "urllib2", "urllib.request"),
+    MovedAttribute("ProxyHandler", "urllib2", "urllib.request"),
+    MovedAttribute("BaseHandler", "urllib2", "urllib.request"),
+    MovedAttribute("HTTPPasswordMgr", "urllib2", "urllib.request"),
+    MovedAttribute("HTTPPasswordMgrWithDefaultRealm", "urllib2", "urllib.request"),
+    MovedAttribute("AbstractBasicAuthHandler", "urllib2", "urllib.request"),
+    MovedAttribute("HTTPBasicAuthHandler", "urllib2", "urllib.request"),
+    MovedAttribute("ProxyBasicAuthHandler", "urllib2", "urllib.request"),
+    MovedAttribute("AbstractDigestAuthHandler", "urllib2", "urllib.request"),
+    MovedAttribute("HTTPDigestAuthHandler", "urllib2", "urllib.request"),
+    MovedAttribute("ProxyDigestAuthHandler", "urllib2", "urllib.request"),
+    MovedAttribute("HTTPHandler", "urllib2", "urllib.request"),
+    MovedAttribute("HTTPSHandler", "urllib2", "urllib.request"),
+    MovedAttribute("FileHandler", "urllib2", "urllib.request"),
+    MovedAttribute("FTPHandler", "urllib2", "urllib.request"),
+    MovedAttribute("CacheFTPHandler", "urllib2", "urllib.request"),
+    MovedAttribute("UnknownHandler", "urllib2", "urllib.request"),
+    MovedAttribute("HTTPErrorProcessor", "urllib2", "urllib.request"),
+    MovedAttribute("urlretrieve", "urllib", "urllib.request"),
+    MovedAttribute("urlcleanup", "urllib", "urllib.request"),
+    MovedAttribute("URLopener", "urllib", "urllib.request"),
+    MovedAttribute("FancyURLopener", "urllib", "urllib.request"),
+    MovedAttribute("proxy_bypass", "urllib", "urllib.request"),
+]
+for attr in _urllib_request_moved_attributes:
+    setattr(Module_six_moves_urllib_request, attr.name, attr)
+del attr
+
+Module_six_moves_urllib_request._moved_attributes = _urllib_request_moved_attributes
+
+_importer._add_module(Module_six_moves_urllib_request(__name__ + ".moves.urllib.request"),
+                      "moves.urllib_request", "moves.urllib.request")
+
+
+class Module_six_moves_urllib_response(_LazyModule):
+    """Lazy loading of moved objects in six.moves.urllib_response"""
+
+
+_urllib_response_moved_attributes = [
+    MovedAttribute("addbase", "urllib", "urllib.response"),
+    MovedAttribute("addclosehook", "urllib", "urllib.response"),
+    MovedAttribute("addinfo", "urllib", "urllib.response"),
+    MovedAttribute("addinfourl", "urllib", "urllib.response"),
+]
+for attr in _urllib_response_moved_attributes:
+    setattr(Module_six_moves_urllib_response, attr.name, attr)
+del attr
+
+Module_six_moves_urllib_response._moved_attributes = _urllib_response_moved_attributes
+
+_importer._add_module(Module_six_moves_urllib_response(__name__ + ".moves.urllib.response"),
+                      "moves.urllib_response", "moves.urllib.response")
+
+
+class Module_six_moves_urllib_robotparser(_LazyModule):
+    """Lazy loading of moved objects in six.moves.urllib_robotparser"""
+
+
+_urllib_robotparser_moved_attributes = [
+    MovedAttribute("RobotFileParser", "robotparser", "urllib.robotparser"),
+]
+for attr in _urllib_robotparser_moved_attributes:
+    setattr(Module_six_moves_urllib_robotparser, attr.name, attr)
+del attr
+
+Module_six_moves_urllib_robotparser._moved_attributes = _urllib_robotparser_moved_attributes
+
+_importer._add_module(Module_six_moves_urllib_robotparser(__name__ + ".moves.urllib.robotparser"),
+                      "moves.urllib_robotparser", "moves.urllib.robotparser")
+
+
+class Module_six_moves_urllib(types.ModuleType):
+    """Create a six.moves.urllib namespace that resembles the Python 3 namespace"""
+    __path__ = []  # mark as package
+    parse = _importer._get_module("moves.urllib_parse")
+    error = _importer._get_module("moves.urllib_error")
+    request = _importer._get_module("moves.urllib_request")
+    response = _importer._get_module("moves.urllib_response")
+    robotparser = _importer._get_module("moves.urllib_robotparser")
+
+    def __dir__(self):
+        return ['parse', 'error', 'request', 'response', 'robotparser']
+
+_importer._add_module(Module_six_moves_urllib(__name__ + ".moves.urllib"),
+                      "moves.urllib")
+
+
+def add_move(move):
+    """Add an item to six.moves."""
+    setattr(_MovedItems, move.name, move)
+
+
+def remove_move(name):
+    """Remove item from six.moves."""
+    try:
+        delattr(_MovedItems, name)
+    except AttributeError:
+        try:
+            del moves.__dict__[name]
+        except KeyError:
+            raise AttributeError("no such move, %r" % (name,))
+
+
+if PY3:
+    _meth_func = "__func__"
+    _meth_self = "__self__"
+
+    _func_closure = "__closure__"
+    _func_code = "__code__"
+    _func_defaults = "__defaults__"
+    _func_globals = "__globals__"
+else:
+    _meth_func = "im_func"
+    _meth_self = "im_self"
+
+    _func_closure = "func_closure"
+    _func_code = "func_code"
+    _func_defaults = "func_defaults"
+    _func_globals = "func_globals"
+
+
+try:
+    advance_iterator = next
+except NameError:
+    def advance_iterator(it):
+        return it.next()
+next = advance_iterator
+
+
+try:
+    callable = callable
+except NameError:
+    def callable(obj):
+        return any("__call__" in klass.__dict__ for klass in type(obj).__mro__)
+
+
+if PY3:
+    def get_unbound_function(unbound):
+        return unbound
+
+    create_bound_method = types.MethodType
+
+    Iterator = object
+else:
+    def get_unbound_function(unbound):
+        return unbound.im_func
+
+    def create_bound_method(func, obj):
+        return types.MethodType(func, obj, obj.__class__)
+
+    class Iterator(object):
+
+        def next(self):
+            return type(self).__next__(self)
+
+    callable = callable
+_add_doc(get_unbound_function,
+         """Get the function out of a possibly unbound function""")
+
+
+get_method_function = operator.attrgetter(_meth_func)
+get_method_self = operator.attrgetter(_meth_self)
+get_function_closure = operator.attrgetter(_func_closure)
+get_function_code = operator.attrgetter(_func_code)
+get_function_defaults = operator.attrgetter(_func_defaults)
+get_function_globals = operator.attrgetter(_func_globals)
+
+
+if PY3:
+    def iterkeys(d, **kw):
+        return iter(d.keys(**kw))
+
+    def itervalues(d, **kw):
+        return iter(d.values(**kw))
+
+    def iteritems(d, **kw):
+        return iter(d.items(**kw))
+
+    def iterlists(d, **kw):
+        return iter(d.lists(**kw))
+else:
+    def iterkeys(d, **kw):
+        return iter(d.iterkeys(**kw))
+
+    def itervalues(d, **kw):
+        return iter(d.itervalues(**kw))
+
+    def iteritems(d, **kw):
+        return iter(d.iteritems(**kw))
+
+    def iterlists(d, **kw):
+        return iter(d.iterlists(**kw))
+
+_add_doc(iterkeys, "Return an iterator over the keys of a dictionary.")
+_add_doc(itervalues, "Return an iterator over the values of a dictionary.")
+_add_doc(iteritems,
+         "Return an iterator over the (key, value) pairs of a dictionary.")
+_add_doc(iterlists,
+         "Return an iterator over the (key, [values]) pairs of a dictionary.")
+
+
+if PY3:
+    def b(s):
+        return s.encode("latin-1")
+    def u(s):
+        return s
+    unichr = chr
+    if sys.version_info[1] <= 1:
+        def int2byte(i):
+            return bytes((i,))
+    else:
+        # This is about 2x faster than the implementation above on 3.2+
+        int2byte = operator.methodcaller("to_bytes", 1, "big")
+    byte2int = operator.itemgetter(0)
+    indexbytes = operator.getitem
+    iterbytes = iter
+    import io
+    StringIO = io.StringIO
+    BytesIO = io.BytesIO
+else:
+    def b(s):
+        return s
+    # Workaround for standalone backslash
+    def u(s):
+        return unicode(s.replace(r'\\', r'\\\\'), "unicode_escape")
+    unichr = unichr
+    int2byte = chr
+    def byte2int(bs):
+        return ord(bs[0])
+    def indexbytes(buf, i):
+        return ord(buf[i])
+    def iterbytes(buf):
+        return (ord(byte) for byte in buf)
+    import StringIO
+    StringIO = BytesIO = StringIO.StringIO
+_add_doc(b, """Byte literal""")
+_add_doc(u, """Text literal""")
+
+
+if PY3:
+    exec_ = getattr(moves.builtins, "exec")
+
+
+    def reraise(tp, value, tb=None):
+        if value.__traceback__ is not tb:
+            raise value.with_traceback(tb)
+        raise value
+
+else:
+    def exec_(_code_, _globs_=None, _locs_=None):
+        """Execute code in a namespace."""
+        if _globs_ is None:
+            frame = sys._getframe(1)
+            _globs_ = frame.f_globals
+            if _locs_ is None:
+                _locs_ = frame.f_locals
+            del frame
+        elif _locs_ is None:
+            _locs_ = _globs_
+        exec("""exec _code_ in _globs_, _locs_""")
+
+
+    exec_("""def reraise(tp, value, tb=None):
+    raise tp, value, tb
+""")
+
+
+print_ = getattr(moves.builtins, "print", None)
+if print_ is None:
+    def print_(*args, **kwargs):
+        """The new-style print function for Python 2.4 and 2.5."""
+        fp = kwargs.pop("file", sys.stdout)
+        if fp is None:
+            return
+        def write(data):
+            if not isinstance(data, basestring):
+                data = str(data)
+            # If the file has an encoding, encode unicode with it.
+            if (isinstance(fp, file) and
+                isinstance(data, unicode) and
+                fp.encoding is not None):
+                errors = getattr(fp, "errors", None)
+                if errors is None:
+                    errors = "strict"
+                data = data.encode(fp.encoding, errors)
+            fp.write(data)
+        want_unicode = False
+        sep = kwargs.pop("sep", None)
+        if sep is not None:
+            if isinstance(sep, unicode):
+                want_unicode = True
+            elif not isinstance(sep, str):
+                raise TypeError("sep must be None or a string")
+        end = kwargs.pop("end", None)
+        if end is not None:
+            if isinstance(end, unicode):
+                want_unicode = True
+            elif not isinstance(end, str):
+                raise TypeError("end must be None or a string")
+        if kwargs:
+            raise TypeError("invalid keyword arguments to print()")
+        if not want_unicode:
+            for arg in args:
+                if isinstance(arg, unicode):
+                    want_unicode = True
+                    break
+        if want_unicode:
+            newline = unicode("\n")
+            space = unicode(" ")
+        else:
+            newline = "\n"
+            space = " "
+        if sep is None:
+            sep = space
+        if end is None:
+            end = newline
+        for i, arg in enumerate(args):
+            if i:
+                write(sep)
+            write(arg)
+        write(end)
+
+_add_doc(reraise, """Reraise an exception.""")
+
+if sys.version_info[0:2] < (3, 4):
+    def wraps(wrapped):
+        def wrapper(f):
+            f = functools.wraps(wrapped)(f)
+            f.__wrapped__ = wrapped
+            return f
+        return wrapper
+else:
+    wraps = functools.wraps
+
+def with_metaclass(meta, *bases):
+    """Create a base class with a metaclass."""
+    # This requires a bit of explanation: the basic idea is to make a dummy
+    # metaclass for one level of class instantiation that replaces itself with
+    # the actual metaclass.
+    class metaclass(meta):
+        def __new__(cls, name, this_bases, d):
+            return meta(name, bases, d)
+    return type.__new__(metaclass, 'temporary_class', (), {})
+
+
+def add_metaclass(metaclass):
+    """Class decorator for creating a class with a metaclass."""
+    def wrapper(cls):
+        orig_vars = cls.__dict__.copy()
+        orig_vars.pop('__dict__', None)
+        orig_vars.pop('__weakref__', None)
+        slots = orig_vars.get('__slots__')
+        if slots is not None:
+            if isinstance(slots, str):
+                slots = [slots]
+            for slots_var in slots:
+                orig_vars.pop(slots_var)
+        return metaclass(cls.__name__, cls.__bases__, orig_vars)
+    return wrapper
+
+# Complete the moves implementation.
+# This code is at the end of this module to speed up module loading.
+# Turn this module into a package.
+__path__ = []  # required for PEP 302 and PEP 451
+__package__ = __name__  # see PEP 366 @ReservedAssignment
+if globals().get("__spec__") is not None:
+    __spec__.submodule_search_locations = []  # PEP 451 @UndefinedVariable
+# Remove other six meta path importers, since they cause problems. This can
+# happen if six is removed from sys.modules and then reloaded. (Setuptools does
+# this for some reason.)
+if sys.meta_path:
+    for i, importer in enumerate(sys.meta_path):
+        # Here's some real nastiness: Another "instance" of the six module might
+        # be floating around. Therefore, we can't use isinstance() to check for
+        # the six meta path importer, since the other six instance will have
+        # inserted an importer with different class.
+        if (type(importer).__name__ == "_SixMetaPathImporter" and
+            importer.name == __name__):
+            del sys.meta_path[i]
+            break
+    del i, importer
+# Finally, add the importer to the meta path import hook.
+sys.meta_path.append(_importer)

doc/CodingStyle.md

@@ -2,14 +2,38 @@
 
 # Coding Standards
 
-Coding standards used here are extreme strict and consistent. The style
-evolved gradually over the years, incorporating generally acknowledged
-best-practice C++ advice, experience, and personal preference.
+Coding standards used here gradually evolve and propagate through 
+code reviews. Some aspects are enforced more strictly than others.
 
-## Don't Repeat Yourself!
+## Rules
 
-The [Don't Repeat Yourself][1] principle summarises the essence of what it
-means to write good code, in all languages, at all levels.
+These rules only apply to our own code. We can't enforce any sort of 
+style on the external repositories and libraries we include. The best
+guideline is to maintain the standards that are used in those libraries.
+
+* Tab inserts 4 spaces. No tab characters.
+* Braces are indented in the [Allman style][1].
+* Modern C++ principles. No naked ```new``` or ```delete```.
+* Line lengths limited to 80 characters. Exceptions limited to data and tables.
+
+## Guidelines
+
+If you want to do something contrary to these guidelines, understand
+why you're doing it. Think, use common sense, and consider that this
+your changes will probably need to be maintained long after you've
+moved on to other projects.
+
+* Use white space and blank lines to guide the eye and keep your intent clear.
+* Put private data members at the top of a class, and the 6 public special
+members immediately after, in the following order:
+  * Destructor
+  * Default constructor
+  * Copy constructor
+  * Copy assignment
+  * Move constructor
+  * Move assignment
+* Don't over-inline by defining large functions within the class
+declaration, not even for template classes.
 
 ## Formatting
 
@@ -17,9 +41,6 @@ The goal of source code formatting should always be to make things as easy to
 read as possible. White space is used to guide the eye so that details are not
 overlooked. Blank lines are used to separate code into "paragraphs."
 
-* No tab characters please.
-* Tab stops are set to 4 spaces.
-* Braces are indented in the [Allman style][2].
 * Always place a space before and after all binary operators,
   especially assignments (`operator=`).
 * The `!` operator should always be followed by a space.
@@ -62,156 +83,4 @@ overlooked. Blank lines are used to separate code into "paragraphs."
 * Always place a space in between the template angle brackets and the type
   name. Template code is already hard enough to read!
 
-## Naming conventions
-
-* Member variables and method names are written with camel-case, and never
-  begin with a capital letter.
-* Class names are also written in camel-case, but always begin with a capital
-  letter.
-* For global variables... well, you shouldn't have any, so it doesn't matter.
-* Class data members begin with `m_`, static data members begin with `s_`.
-  Global variables begin with `g_`. This is so the scope of the corresponding
-  declaration can be easily determined.
-* Avoid underscores in your names, especially leading or trailing underscores.
-  In particular, leading underscores should be avoided, as these are often used
-  in standard library code, so to use them in your own code looks quite jarring.
-* If you really have to write a macro for some reason, then make it all caps,
-  with underscores to separate the words. And obviously make sure that its name
-  is unlikely to clash with symbols used in other libraries or 3rd party code.
-
-## Types, const-correctness
-
-* If a method can (and should!) be const, make it const!
-* If a method definitely doesn't throw an exception (be careful!), mark it as
-  `noexcept`
-* When returning a temporary object, e.g. a String, the returned object should
-  be non-const, so that if the class has a C++11 move operator, it can be used.
-* If a local variable can be const, then make it const!
-* Remember that pointers can be const as well as primitives; For example, if
-  you have a `char*` whose contents are going to be altered, you may still be
-  able to make the pointer itself const, e.g. `char* const foobar = getFoobar();`.
-* Do not declare all your local variables at the top of a function or method
-  (i.e. in the old-fashioned C-style). Declare them at the last possible moment,
-  and give them as small a scope as possible.
-* Object parameters should be passed as `const&` wherever possible. Only
-  pass a parameter as a copy-by-value object if you really need to mutate
-  a local copy inside the method, and if making a local copy inside the method
-  would be difficult.
-* Use portable `for()` loop variable scoping (i.e. do not have multiple for
-  loops in the same scope that each re-declare the same variable name, as
-  this fails on older compilers)
-* When you're testing a pointer to see if it's null, never write
-  `if (myPointer)`. Always avoid that implicit cast-to-bool by writing it more
-  fully: `if (myPointer != nullptr)`. And likewise, never ever write
-  `if (! myPointer)`, instead always write `if (myPointer == nullptr)`.
-  It is more readable that way.
-* Avoid C-style casts except when converting between primitive numeric types.
-  Some people would say "avoid C-style casts altogether", but `static_cast` is
-  a bit unreadable when you just want to cast an `int` to a `float`. But
-  whenever a pointer is involved, or a non-primitive object, always use
-  `static_cast`. And when you're reinterpreting data, always use
-  `reinterpret_cast`.
-* Until C++ gets a universal 64-bit primitive type (part of the C++11
-  standard), it's best to stick to the `int64` and `uint64` typedefs.
-
-## Object lifetime and ownership
-
-* Absolutely do NOT use `delete`, `deleteAndZero`, etc. There are very very few
-  situations where you can't use a `ScopedPointer` or some other automatic
-  lifetime management class.
-* Do not use `new` unless there's no alternative. Whenever you type `new`, always
-  treat it as a failure to find a better solution. If a local variable can be
-  allocated on the stack rather than the heap, then always do so.
-* Do not ever use `new` or `malloc` to allocate a C++ array. Always use a
-  `HeapBlock` instead.
-* And just to make it doubly clear: Never use `malloc` or `calloc`.
-* If a parent object needs to create and own some kind of child object, always
-  use composition as your first choice. If that's not possible (e.g. if the
-  child needs a pointer to the parent for its constructor), then use a
-  `ScopedPointer`.
-* If possible, pass an object as a reference rather than a pointer. If possible,
-  make it a `const` reference.
-* Obviously avoid static and global values. Sometimes there's no alternative,
-  but if there is an alternative, then use it, no matter how much effort it
-  involves.
-* If allocating a local POD structure (e.g. an operating-system structure in
-  native code), and you need to initialise it with zeros, use the `= { 0 };`
-  syntax as your first choice for doing this. If for some reason that's not
-  appropriate, use the `zerostruct()` function, or in case that isn't suitable,
-  use `zeromem()`. Don't use `memset()`.
-
-## Classes
-
-* Declare a class's public section first, and put its constructors and
-  destructor first. Any protected items come next, and then private ones.
-* Use the most restrictive access-specifier possible for each member. Prefer
-  `private` over `protected`, and `protected` over `public`. Don't expose
-  things unnecessarily.
-* Preferred positioning for any inherited classes is to put them to the right
-  of the class name, vertically aligned, e.g.:
-        class Thing  : public Foo, 
-                       private Bar
-        {
-        }
-* Put a class's member variables (which should almost always be private, of course),
-  after all the public and protected method declarations.
-* Any private methods can go towards the end of the class, after the member
-  variables.
-* If your class does not have copy-by-value semantics, derive the class from
-  `Uncopyable`.
-* If your class is likely to be leaked, then derive your class from
-  `LeakChecked<>`.
-* Constructors that take a single parameter should be default be marked
-  `explicit`. Obviously there are cases where you do want implicit conversion,
-  but always think about it carefully before writing a non-explicit constructor.
-* Do not use `NULL`, `null`, or 0 for a null-pointer. And especially never use
-  '0L', which is particulary burdensome. Use `nullptr` instead - this is the
-  C++2011 standard, so get used to it. There's a fallback definition for `nullptr`
-  in Beast, so it's always possible to use it even if your compiler isn't yet
-  C++2011 compliant.
-* All the C++ 'guru' books and articles are full of excellent and detailed advice
-  on when it's best to use inheritance vs composition. If you're not already
-  familiar with the received wisdom in these matters, then do some reading!
-
-## Miscellaneous
-
-* `goto` statements should not be used at all, even if the alternative is
-  more verbose code. The only exception is when implementing an algorithm in
-  a function as a state machine.
-* Don't use macros! OK, obviously there are many situations where they're the
-  right tool for the job, but treat them as a last resort. Certainly don't ever
-  use a macro just to hold a constant value or to perform any kind of function
-  that could have been done as a real inline function. And it goes without saying
-  that you should give them names which aren't going to clash with other code.
-  And `#undef` them after you've used them, if possible.
-* When using the `++` or `--` operators, never use post-increment if
-  pre-increment could be used instead. Although it doesn't matter for
-  primitive types, it's good practice to pre-increment since this can be
-  much more efficient for more complex objects. In particular, if you're
-  writing a for loop, always use pre-increment,
-  e.g. `for (int = 0; i < 10; ++i)`
-* Never put an "else" statement after a "return"! This is well-explained in the
-  LLVM coding standards...and a couple of other very good pieces of advice from
-  the LLVM standards are in there as well.
-* When getting a possibly-null pointer and using it only if it's non-null, limit
-  the scope of the pointer as much as possible - e.g. Do NOT do this:
-
-        Foo* f = getFoo ();
-        if (f != nullptr)
-            f->doSomething ();
-        // other code
-        f->doSomething ();  // oops! f may be null!
-
-  ..instead, prefer to write it like this, which reduces the scope of the
-  pointer, making it impossible to write code that accidentally uses a null
-  pointer:
-
-        if (Foo* f = getFoo ())
-            f->doSomethingElse ();
-
-        // f is out-of-scope here, so impossible to use it if it's null
-
-  (This also results in smaller, cleaner code)
-
-[1]: http://en.wikipedia.org/wiki/Don%27t_repeat_yourself
-[2]: http://en.wikipedia.org/wiki/Indent_style#Allman_style
+[1]: http://en.wikipedia.org/wiki/Indent_style#Allman_style

doc/HeapProfiling.md

@@ -0,0 +1,63 @@
+## Heap profiling of rippled with jemalloc
+
+The jemalloc library provides a good API for doing heap analysis,
+including a mechanism to dump a description of the heap from within the
+running application via a function call. Details on how to perform this
+activity in general, as well as how to acquire the software, are available on
+the jemalloc site:
+[https://github.com/jemalloc/jemalloc/wiki/Use-Case:-Heap-Profiling](https://github.com/jemalloc/jemalloc/wiki/Use-Case:-Heap-Profiling)
+
+jemalloc is acquired separately from rippled, and is not affiliated
+with Ripple Labs. If you compile and install jemalloc from the
+source release with default options, it will install the library and header
+under `/usr/local/lib` and `/usr/local/include`, respectively. Heap
+profiling has been tested with rippled on a Linux platform. It should
+work on platforms on which both rippled and jemalloc are available.
+
+To link rippled with jemalloc, the argument
+`profile-jemalloc=<jemalloc_dir>` is provided after the optional target.
+The `<jemalloc_dir>` argument should be the same as that of the
+`--prefix` parameter passed to the jemalloc configure script when building.
+
+## Examples:
+
+Build rippled with jemalloc library under /usr/local/lib and
+header under /usr/local/include:
+
+    $ scons profile-jemalloc=/usr/local
+
+Build rippled using clang with the jemalloc library under /opt/local/lib
+and header under /opt/local/include:
+
+    $ scons clang profile-jemalloc=/opt/local
+
+----------------------
+
+## Using the jemalloc library from within the code
+
+The `profile-jemalloc` parameter enables a macro definition called
+`PROFILE_JEMALLOC`. Include the jemalloc header file as
+well as the api call(s) that you wish to make within preprocessor
+conditional groups, such as:
+
+In global scope:
+
+    #ifdef PROFILE_JEMALLOC
+    #include <jemalloc/jemalloc.h>
+    #endif
+
+And later, within a function scope:
+
+    #ifdef PROFILE_JEMALLOC
+    mallctl("prof.dump", NULL, NULL, NULL, 0);
+    #endif
+
+Fuller descriptions of how to acquire and use jemalloc's api to do memory
+analysis are available at the [jemalloc
+site.](http://www.canonware.com/jemalloc/)
+
+Linking against the jemalloc library will override
+the system's default `malloc()` and related functions with jemalloc's
+implementation. This is the case even if the code is not instrumented
+to use jemalloc's specific API.
+

doc/rippled-example.cfg

@@ -27,12 +27,12 @@
 # Purpose
 #
 #   This file documents and provides examples of all rippled server process
-#   configuration options. When the rippled server instance is lanched, it looks
-#   for a file with the following name:
+#   configuration options. When the rippled server instance is launched, it
+#   looks for a file with the following name:
 #
 #     rippled.cfg
 #
-#   For more information on where the rippled serer instance searches for
+#   For more information on where the rippled server instance searches for
 #   the file please visit the Ripple wiki. Specifically, the section explaining
 #   the --conf command line option:
 #
@@ -91,6 +91,8 @@
 #   One IPv4 address or domain names per line is allowed. A port may optionally
 #   be specified after adding a space to the address.
 #
+#
+#
 # [peer_ip]
 #
 #   IP address or domain to bind to allow external connections from peers.
@@ -123,6 +125,8 @@
 #   to configure your server instance to receive PROXY Protocol handshakes,
 #   and also to restrict access to your instance to the Elastic Load Balancer.
 #
+#
+#
 # [peer_private]
 #
 #   0 or 1.
@@ -132,6 +136,15 @@
 #
 #
 #
+# [peers_max]
+#
+#   The largest number of desired peer connections (incoming or outgoing).
+#   Cluster and fixed peers do not count towards this total. There are
+#   implementation-defined lower limits imposed on this value for security
+#   purposes.
+#
+#
+#
 # [peer_ssl_cipher_list]
 #
 #   A colon delimited string with the allowed SSL cipher modes for peer. The
@@ -229,7 +242,7 @@
 #
 #   The amount of time to wait in seconds, before sending a websocket 'ping'
 #   message. Ping messages are used to determine if the remote end of the
-#   connection is no longer availabile.
+#   connection is no longer available.
 #   
 #
 #
@@ -286,7 +299,7 @@
 #
 #   This group of settings configures security and access attributes of the
 #   RPC server section of the rippled process, used to service both local
-#   an optional remote clients.
+#   and optional remote clients.
 #
 #
 #
@@ -301,7 +314,7 @@
 #
 # [rpc_admin_allow]
 #
-#   Specify an list of IP addresses allowed to have admin access. One per line.
+#   Specify a list of IP addresses allowed to have admin access. One per line.
 #   If you want to test the output of non-admin commands add this section and
 #   just put an ip address not under your control.
 #   Defaults to 127.0.0.1.
@@ -321,7 +334,7 @@
 #
 # [rpc_admin_password]
 #
-#   As a server, require this as the admin pasword to be specified.  Also,
+#   As a server, require this as the admin password to be specified.  Also,
 #   require rpc_admin_user and rpc_admin_password to be checked for RPC admin
 #   functions.  The request must specify these as the admin_user and
 #   admin_password in the request object.
@@ -345,7 +358,7 @@
 #
 # [rpc_user]
 #
-#   As a server, require a this user to specified and require rpc_password to
+#   As a server, require this user to be specified and require rpc_password to
 #   be checked for RPC access via the rpc_ip and rpc_port. The user and password
 #   must be specified via HTTP's basic authentication method.
 #   As a client, supply this to the server via HTTP's basic authentication
@@ -355,7 +368,7 @@
 #
 # [rpc_password]
 #
-#   As a server, require a this password to specified and require rpc_user to
+#   As a server, require this password to be specified and require rpc_user to
 #   be checked for RPC access via the rpc_ip and rpc_port. The user and password
 #   must be specified via HTTP's basic authentication method.
 #   As a client, supply this to the server via HTTP's basic authentication
@@ -380,8 +393,9 @@
 #   0: Server certificates are not provided for RPC clients using SSL [default]
 #   1: Client RPC connections wil be provided with SSL certificates.
 #
-#   Note that if rpc_secure is enabled, it will also be necessasry to configure the
-#   certificate file settings located in rpc_ssl_cert, rpc_ssl_chain, and rpc_ssl_key
+#   Note that if rpc_secure is enabled, it will also be necessary to configure
+#   the certificate file settings located in rpc_ssl_cert, rpc_ssl_chain, and
+#   rpc_ssl_key
 #
 #
 #
@@ -389,8 +403,9 @@
 #
 #   <pathname>
 #
-#   A file system path leading to the SSL certificate file to use for secure RPC.
-#   The file is in PEM format. The file is not needed if the chain includes it.
+#   A file system path leading to the SSL certificate file to use for secure
+#   RPC.  The file is in PEM format. The file is not needed if the chain
+#   includes it.
 #
 #
 #
@@ -431,7 +446,7 @@
 #
 #     [sms_url]?from=[sms_from]&to=[sms_to]&api_key=[sms_key]&api_secret=[sms_secret]&text=['text']
 #
-#   Where [...] are the corresponding valus from the configuration file, and
+#   Where [...] are the corresponding values from the configuration file, and
 #   ['test'] is the value of the JSON field with name 'text'.
 #
 # [sms_url]
@@ -525,8 +540,8 @@
 #   For domains, rippled will probe for https web servers at the specified
 #   domain in the following order: ripple.DOMAIN, www.DOMAIN, DOMAIN
 #
-#   For public key entries, a comment may optionally be spcified after adding a
-#   space to the pulic key.
+#   For public key entries, a comment may optionally be specified after adding
+#   a space to the public key.
 #
 #   Examples:
 #    ripple.com
@@ -574,14 +589,14 @@
 #
 # [path_search_fast]
 # [path_search_max]
-#   When seaching for paths, the minimum and maximum search aggressiveness.
+#   When searching for paths, the minimum and maximum search aggressiveness.
 #
 #   The default for 'path_search_fast' is 2. The default for 'path_search_max' is 10.
 #
 # [path_search_old]
 #
 #   For clients that use the legacy path finding interfaces, the search
-#   agressiveness to use. The default is 7.
+#   agressivness to use. The default is 7.
 #
 #
 #
@@ -662,19 +677,20 @@
 #   Examples:
 #       type=HyperLevelDB
 #       path=db/hyperldb
+#       compression=0
 #
 #   Choices for 'type' (not case-sensitive)
-#       HyperLevelDB        Use an improved version of LevelDB (preferred)
+#       RocksDB             Use Facebook's RocksDB database (preferred)
+#       HyperLevelDB        Use an improved version of LevelDB
+#       SQLite              Use SQLite
 #       LevelDB             Use Google's LevelDB database (deprecated)
 #       none                Use no backend
-#       RocksDB             Use Facebook's RocksDB database
-#       SQLite              Use SQLite
 #
 #   Required keys:
 #       path                Location to store the database (all types)
 #
 #   Optional keys:
-#       (none yet)
+#       compression         0 for none, 1 for Snappy compression
 #
 #   Notes:
 #       The 'node_db' entry configures the primary, persistent storage.
@@ -793,10 +809,20 @@
 [node_size]
 medium
 
-# Note that HyperLevelDB is unavailable on Windows platforms
+# This is primary persistent datastore for rippled.  This includes transaction
+# metadata, account states, and ledger headers.  Helpful information can be
+# found here: https://ripple.com/wiki/NodeBackEnd
 [node_db]
-type=HyperLevelDB
-path=/etc/ripple/db/hyperldb
+type=RocksDB
+path=/var/lib/rippled/db/rocksdb
+open_files=2000
+filter_bits=12
+cache_mb=256
+file_size_mb=8
+file_size_mult=2
+
+[database_path]
+/var/lib/rippled/db
 
 # This needs to be an absolute directory reference, not a relative one.
 # Modify this value as required.
@@ -814,16 +840,41 @@ pool.ntp.org
 [ips]
 r.ripple.com 51235
 
-# These validators are taken from the v0.16 release notes on the wiki:
-# https://ripple.com/wiki/Latest_rippled_release_notes
+# The latest validators can be obtained from
+# https://ripple.com/ripple.txt
+#
 [validators]
-n9KPnVLn7ewVzHvn218DcEYsnWLzKerTDwhpofhk4Ym1RUq4TeGw    RIP1
-n9LFzWuhKNvXStHAuemfRKFVECLApowncMAM5chSCL9R5ECHGN4V    RIP2
-n94rSdgTyBNGvYg8pZXGuNt59Y5bGAZGxbxyvjDaqD9ceRAgD85P    RIP3
-n9LeQeDcLDMZKjx1TZtrXoLBLo5q1bR1sUQrWG7tEADFU6R27UBp    RIP4
-n9KF6RpvktjNs2MDBkmxpJbup4BKrKeMKDXPhaXkq7cKTwLmWkFr    RIP5
+n949f75evCHwgyP4fPVgaHqNHxUVN15PsJEZ3B3HnXPcPjcZAoy7	RL1
+n9MD5h24qrQqiyBC8aeqqCWvpiBiYQ3jxSr91uiDvmrkyHRdYLUj	RL2
+n9L81uNCaPgtUJfaHh89gmdvXKAmSt5Gdsw2g1iPWaPkAHW5Nm4C	RL3
+n9KiYM9CgngLvtRCQHZwgC2gjpdaZcCcbt3VboxiNFcKuwFVujzS	RL4
+n9LdgEtkmGB9E2h3K4Vp7iGUaKuq23Zr32ehxiU8FWY7xoxbWTSA	RL5
 
 # Ditto.
 [validation_quorum]
 3
 
+# Turn down default logging to save disk space in the long run.
+# Valid values here are trace, debug, info, warning, error, and fatal
+[rpc_startup]
+{ "command": "log_level", "severity": "warning" }
+
+# Configure SSL for WebSockets.  Not enabled by default because not everybody
+# has an SSL cert on their server, but if you uncomment the following lines and
+# set the path to the SSL certificate and private key the WebSockets protocol
+# will be protected by SSL/TLS.
+#[websocket_secure]
+#1
+
+#[websocket_ssl_cert]
+#/etc/ssl/certs/server.crt
+
+#[websocket_ssl_key]
+#/etc/ssl/private/server.key
+
+# Defaults to 0 ("no") so that you can use self-signed SSL certificates for
+# development, or internally.
+#[ssl_verify]
+#0
+
+

doc/rippled-example.service

@@ -0,0 +1,10 @@
+[Unit]
+Description=Ripple Peer-to-Peer Network Daemon
+ 
+[Service]
+Type=simple
+User=nobody
+ExecStart=/usr/bin/rippled --conf=/etc/rippled/rippled.cfg
+ 
+[Install]
+WantedBy=multi-user.target

doc/todo/VFALCO_TODO.txt

@@ -1,207 +0,0 @@
---------------------------------------------------------------------------------
-RIPPLE TODO
---------------------------------------------------------------------------------
-
-Vinnie's List: Changes day to day, descending priority
-- PeerFinder work
-- Validators work
-- HTTPClient improvements based on HTTPServer
-- HTTPMessage improvements
-- Ditch old HTTPClient so I can take the name
-- Finish RPCAsyncServer, RPCService and RPCService::Manager
-- Fix RPCDoor to respect config setting for [rpc_secure]
-- Clean up calculation of COnfig file location.
-- Remove TESTNET and all related code and settings.
-- Remove addRpcSub, findRpcSub, and notify the appropriate partner(s)
-
-David Features:
-- override config items from command line
-- change config via RPC, this is for debugging
-
---------------------------------------------------------------------------------
-
-- std::priority_queue for DeadlineTimer
-
-- Change ProxyInfo to use IP::Endpoint, get rid of IPv4Address from the parsing
-  code
-
-- Validators should delay the application of newly downloaded lists from
-  sources, to mitigate the effects of attacks. Unless there's no validators
-  in the list.
-
-- Validators RPC options to immediately apply UNL,
-  manually revisit sources, etc...
-
-- Look into using CMake
-
-- IPv6 support in IP::Endpoint
-
-- Configuration list for Jenkins
-
-- Fix all crash and leaks on exit
-    Say there's a leak, a ledger that can never be accessed is locked in some
-        structure. If the organized teardown code frees that structure, the leak
-        will not be reported.
-    Yes, so you'll detect some small subset of leaks that way.
-    You'll still have to be vigilant for the leaks that won't detect.
-    The problem is ordering. There are lots of circular dependencies.
-    The biggest problem is the order of destruction of global objects. (I think)
-    Getting rid of global objects is a good solution to that.
-    Vinnie Falco: Those I can resolve with my ReferenceCountedSingleton. And
-                  yeah thats a good approach, one that I am doing slowly anyway
-    Yeah, that's good for other reasons too, not just the unpredictability of
-        creation order that can hide bugs.
-    There may also just be some missing destructors.
-    Some of it may be things being shut down in the wrong order. Like if you shut
-        down the cache and then something that uses the cache, objects may get
-        put in the cache after it was shut down.
-
-- Do something about the throw() reporting weaknesses:
-  * Make sure all Sconstruct and .pro builds have debug symbols in release
-  * Replace all throw with beast::Throw()
-    (Only in ripple sources, not in Subtrees/, protobuf, or websocket)
-  - Improved Beast exception object, provides __FILE__ and __LINE__
-  - Add file and line capabilities to beast::Throw()
-  - Allow beast::Throw to be hooked for logging
-  - Add stack trace capability to beast::Throw() diagnostics via the hook
-    (use the existing beast::SystemStats::getStackBacktrace())
-  - Implement getStackBacktrace for BEAST_BSD targets
-  - Add UnhandledExceptionCatcher to beast
-  - Return EXIT_FAILURE on unhandled exception
-
-- Consolidate JSON code maybe use Beast
-
-- Deeply create directories specified in config settings
-
-- Refactor Section code into ConfigFile
-
-- Supress useless gcc warnings
-  http://stackoverflow.com/questions/3378560/how-to-disable-gcc-warnings-for-a-few-lines-of-code
-
-- Get rid of boost::filesystem
-
-- What the heck is up with site_scons/site_tools/protoc.py?
-
-- Add convenience variadic functions to JobQueue that do the bind for you
-
-- Consolidate databases
-
-- Figure out why we need WAL sqlite mode if we no longer use sqlite for the node store
-
-- Add "skipped" field to beginTestCase() to disable a test but still record
-  that it was skipped in the output. Like for mdb import.
-
-- Get rid of 'ref' typedefs that really mean const&
-
-- Use secp256k1 from beast
-
-- Fix xsd/dtd line in JUnit XML output
-
-- Get rid of the WriteLog() stuff in the ripple tests and make it report the
-  message directly to the UnitTest object. Then update the JUnit XML output
-  routines to also write the auxiliary messages.
-
-* Restyle all the macros in ConfigSection.h
-
-- Move src/protobuf to Subtrees and deal with protobuf_core.cpp
-
-- Replace home-made database wrappers with beast::sqdb
-
-- Use static creation member functions instead of endless constructor
-  variations in base_uint, uint256, and family.
-
-- Raise the warning level and fix everything
-
-- Replace base_uint and uintXXX with UnsignedInteger
-  * Need to specialize UnsignedInteger to work efficiently with 4 and 8 byte
-    multiples of the size.
-
-- Rewrite boost program_options in Beast
-
-- Replace endian conversion calls with beast calls:
-  htobe32, be32toh, ntohl, etc...
-  Start by removing the system headers which provide these routines, if possible
-
-- Rename RPCHandler to CallHandler
-
-- Rename "fullBelow" to something like haveAllDescendants or haveAllChildren.
-
-- Rewrite Sustain to use Beast and work on Windows as well
-  * Do not enable watchdog process if a debugger is attached
-
-- Make sure the leak detector output appears on Linux and FreeBSD debug builds.
-
-- Rename LoadMonitor to LoadMeter, change LoadEvent to LoadMeter::ScopedSample
-
-- Rename LedgerMaster to Ledgers, create ILedgers interface.
-
-- Replace all NULL with nullptr
-
-- Make TxFormats a member of ICore instead of a singleton.
-  PROBLEM: STObject derived classes like STInt16 make direct use of the
-           singleton. It might have to remain a singleton. At the very least,
-           it should be a SharedSingleton to resolve ordering issues.
-
-- Replace C11X with BEAST_COMPILER_SUPPORTS_MOVE_SEMANTICS
-
-- Remove "ENABLE_INSECURE" when the time is right.
-
-- lift unique_ptr / auto_ptr into ripple namespace,
-  or replace with ScopedPointer (preferred)
-
-- Go searching through VFALCO notes and fix everything
-
-- Deal with function-level statics used for SqliteDatabase (like in
-  HSBESQLite::visitAll)
-
-- Document in order:
-    SerializedType
-    STObject
-    SerializedLedgerEntry
-
-- Consolidate SQLite database classes: DatabaseCon, Database, SqliteDatabase.
-
---------------------------------------------------------------------------------
-WEBSOCKET TODO
---------------------------------------------------------------------------------
-
-- Rewrite for sanity
-
---------------------------------------------------------------------------------
-PROTOCOL BUFFERS TODO
---------------------------------------------------------------------------------
-
-- Create/maintain the protobuf Git repo (original uses SVN)
-
-- Update the subtree
-
-- Make a Visual Studio 2012 Project for source browsing
-
---------------------------------------------------------------------------------
-Davidisms
---------------------------------------------------------------------------------
-
-(Figure out a good place to record information like this permanently)
-
-Regarding a defect where a failing transaction was being submitted over and over
-  again on the network (July 3, 2013)
-
-  The core problem was an interaction between two bits of logic.
-  1) Normally, we won't relay a transaction again if we already recently relayed
-     it. But this is bypassed if the transaction failed in a way that could
-     allow it to succeed later. This way, if one server discovers a transaction
-     can now work, it can get all servers to retry it.
-  2) Normally, we won't relay a transaction if we think it can't claim a fee.
-     But if we're not sure it can't claim a fee because we're in an unhealthy
-     state, we propagate the transaction to let other servers decide if they
-     think it can claim a fee.
-  With these two bits of logic, two unhealthy servers could infinitely propagate
-     a transaction back and forth between each other.
-
-A node is "full below" if we believe we have (either in the database or
-  scheduled to be stored in the database) the contents of every node below that
-  node in a hash tree. When trying to acquire a hash tree/map, if a node is
-  full below, we know not to bother with anything below that node.
-
-The fullBelowCache is a cache of hashes of nodes that are full below. Which means
-  there are no missing children

doc/validators-example.txt

@@ -20,6 +20,8 @@
 #
 
 [validators]
-n9KPnVLn7ewVzHvn218DcEYsnWLzKerTDwhpofhk4Ym1RUq4TeGw	first
-n9LFzWuhKNvXStHAuemfRKFVECLApowncMAM5chSCL9R5ECHGN4V	second
-n94rSdgTyBNGvYg8pZXGuNt59Y5bGAZGxbxyvjDaqD9ceRAgD85P	third
+n949f75evCHwgyP4fPVgaHqNHxUVN15PsJEZ3B3HnXPcPjcZAoy7 RL1
+n9MD5h24qrQqiyBC8aeqqCWvpiBiYQ3jxSr91uiDvmrkyHRdYLUj RL2
+n9L81uNCaPgtUJfaHh89gmdvXKAmSt5Gdsw2g1iPWaPkAHW5Nm4C RL3
+n9KiYM9CgngLvtRCQHZwgC2gjpdaZcCcbt3VboxiNFcKuwFVujzS RL4
+n9LdgEtkmGB9E2h3K4Vp7iGUaKuq23Zr32ehxiU8FWY7xoxbWTSA RL5

package.json

@@ -10,7 +10,7 @@
   },
 
   "dependencies": {
-    "ripple-lib": "0.7.25",
+    "ripple-lib": "0.7.37",
     "async": "~0.2.9",
     "extend": "~1.2.0",
     "simple-jsonrpc": "~0.0.2",
@@ -31,4 +31,4 @@
   },
 
   "readmeFilename": "README.md"
-}
+}

site_scons/site_tools/protoc.py

@@ -1,88 +0,0 @@
-#!python
-""" 
-protoc.py: Protoc Builder for SCons
-
-This Builder invokes protoc to generate C++ and Python 
-from a .proto file.  
-
-NOTE: Java is not currently supported.
-
-From: http://www.scons.org/wiki/ProtocBuilder
-"""
-
-__author__ = "Scott Stafford"
-
-import SCons.Action
-import SCons.Builder
-import SCons.Defaults
-import SCons.Node.FS
-import SCons.Util
-
-from SCons.Script import File, Dir
-
-import os.path
-
-protocs = 'protoc'
-
-ProtocAction = SCons.Action.Action('$PROTOCCOM', '$PROTOCCOMSTR')
-def ProtocEmitter(target, source, env):
-    dirOfCallingSConscript = Dir('.').srcnode()
-    env.Prepend(PROTOCPROTOPATH = dirOfCallingSConscript.path)
-    
-    source_with_corrected_path = []
-    for src in source:
-        commonprefix = os.path.commonprefix([dirOfCallingSConscript.path, src.srcnode().path])
-        if len(commonprefix)>0:
-            source_with_corrected_path.append( src.srcnode().path[len(commonprefix + os.sep):] )
-        else:
-            source_with_corrected_path.append( src.srcnode().path )
-        
-    source = source_with_corrected_path
-    
-    for src in source:
-        modulename = os.path.splitext(os.path.basename(src))[0]
-
-        if env['PROTOCOUTDIR']:            
-            base = os.path.join(env['PROTOCOUTDIR'] , modulename)
-            target.extend( [ base + '.pb.cc', base + '.pb.h' ] )
-        
-        if env['PROTOCPYTHONOUTDIR']:
-            base = os.path.join(env['PROTOCPYTHONOUTDIR'] , modulename)
-            target.append( base + '_pb2.py' )
-
-    try:
-        target.append(env['PROTOCFDSOUT'])
-    except KeyError:
-        pass
-
-    # XXX KLUDGE: Force things to be right.
-    env['PROTOCOUTDIR']	    = 'build/proto'
-    env['PROTOCPROTOPATH']  = ['src/ripple_data/protocol']
-
-    #~ print "PROTOC SOURCE:", [str(s) for s in source]
-    #~ print "PROTOC TARGET:", [str(s) for s in target]
-
-    return target, source
-
-ProtocBuilder = SCons.Builder.Builder(action = ProtocAction,
-                                   emitter = ProtocEmitter,
-                                   srcsuffix = '$PROTOCSRCSUFFIX')
-
-def generate(env):
-    """Add Builders and construction variables for protoc to an Environment."""
-    try:
-        bld = env['BUILDERS']['Protoc']
-    except KeyError:
-        bld = ProtocBuilder
-        env['BUILDERS']['Protoc'] = bld
-        
-    env['PROTOC']        = env.Detect(protocs) or 'protoc'
-    env['PROTOCFLAGS']   = SCons.Util.CLVar('')
-    env['PROTOCPROTOPATH'] = SCons.Util.CLVar('')
-    env['PROTOCCOM']     = '$PROTOC ${["-I%s"%x for x in PROTOCPROTOPATH]} $PROTOCFLAGS --cpp_out=$PROTOCCPPOUTFLAGS$PROTOCOUTDIR ${PROTOCPYTHONOUTDIR and ("--python_out="+PROTOCPYTHONOUTDIR) or ""} ${PROTOCFDSOUT and ("-o"+PROTOCFDSOUT) or ""} ${SOURCES}'
-    env['PROTOCOUTDIR'] = '${SOURCE.dir}'
-    env['PROTOCPYTHONOUTDIR'] = "python"
-    env['PROTOCSRCSUFFIX']  = '.proto'
-
-def exists(env):
-    return env.Detect(protocs)

src/.gitignore

@@ -1,2 +0,0 @@
-# boost subtree
-/boost

src/BeastConfig.h

@@ -27,6 +27,21 @@
     @file BeastConfig.h
 */
 
+//------------------------------------------------------------------------------
+//
+// Unit Tests
+//
+//------------------------------------------------------------------------------
+
+/** Config: BEAST_NO_UNIT_TEST_INLINE
+    Prevents unit test definitions from being inserted into a global table.
+    The default is to include inline unit test definitions.
+*/
+
+#ifndef BEAST_NO_UNIT_TEST_INLINE
+//#define BEAST_NO_UNIT_TEST_INLINE 1
+#endif
+
 //------------------------------------------------------------------------------
 //
 // Diagnostics
@@ -151,16 +166,6 @@
 #define RIPPLE_DUMP_LEAKS_ON_EXIT 1
 #endif
 
-/** Config: RIPPLE_TRACK_MUTEXES
-    Turns on a feature that enables tracking and diagnostics for mutex
-    and recursive mutex objects. This affects the type of lock used
-    by RippleMutex and RippleRecursiveMutex
-    @note This can slow down performance considerably.
-*/
-#ifndef RIPPLE_TRACK_MUTEXES
-#define RIPPLE_TRACK_MUTEXES 0
-#endif
-
 //------------------------------------------------------------------------------
 
 // These control whether or not certain functionality gets
@@ -184,4 +189,54 @@
 #define RIPPLE_USE_VALIDATORS 0
 #endif
 
+/** Config: BEAST_USE_BOOST_FEATURES
+    This activates boost specific features and improvements. If this is
+    turned on, the include paths for your build environment must be set
+    correctly to find the boost headers.
+*/
+#ifndef   BEAST_USE_BOOST_FEATURES
+//#define BEAST_USE_BOOST_FEATURES 1
+#endif
+
+/** Config: RIPPLE_PROPOSE_FEATURES
+    This determines whether to add any features to the proposed transaction set.
+*/
+#ifndef RIPPLE_PROPOSE_AMENDMENTS
+#define RIPPLE_PROPOSE_AMENDMENTS 0
+#endif
+
+/** Config: RIPPLE_ENABLE_AUTOBRIDGING
+    This determines whether ripple implements offer autobridging via XRP.
+*/
+#ifndef RIPPLE_ENABLE_AUTOBRIDGING
+#define RIPPLE_ENABLE_AUTOBRIDGING 0
+#endif
+
+/** Config: RIPPLE_SINGLE_IO_SERVICE_THREAD
+    When set, restricts the number of threads calling io_service::run to one.
+    This is useful when debugging.
+*/
+#ifndef RIPPLE_SINGLE_IO_SERVICE_THREAD
+#define RIPPLE_SINGLE_IO_SERVICE_THREAD 0
+#endif
+
+/** Config: RIPPLE_STRUCTURED_OVERLAY_CLIENT
+            RIPPLE_STRUCTURED_OVERLAY_SERVER
+    Enables Structured Overlay support for the client or server roles.
+    This feature is currently in development:
+        https://ripplelabs.atlassian.net/browse/RIPD-157
+*/
+#ifndef RIPPLE_STRUCTURED_OVERLAY_CLIENT
+#define RIPPLE_STRUCTURED_OVERLAY_CLIENT 0
+#endif
+#ifndef RIPPLE_STRUCTURED_OVERLAY_SERVER
+#define RIPPLE_STRUCTURED_OVERLAY_SERVER 1
+#endif
+
+/** Config: RIPPLE_ASYNC_RPC_HANDLER
+*/
+#ifndef RIPPLE_ASYNC_RPC_HANDLER
+#define RIPPLE_ASYNC_RPC_HANDLER 1
+#endif
+
 #endif

src/README.md

@@ -1,9 +1,9 @@
 # src
 
-Some of these directories come from entire outside repositories
-brought in using git-subtree. This means that the source files are
-inserted directly into the rippled repository. They can be edited
-and committed just as if they were normal files.
+Some of these directories come from entire outside repositories brought in
+using git-subtree. This means that the source files are inserted directly
+into the rippled repository. They can be edited and committed just as if they
+were normal files.
 
 However, if you create a commit that contains files both from a
 subtree, and from the ripple source tree please use care when designing
@@ -99,7 +99,7 @@ ripple-fork
 ## protobuf
 
 Ripple's fork of protobuf. We've changed some names in order to support the
-unity-style of build (a single .cpp addded to the project, instead of
+unity-style of build (a single .cpp added to the project, instead of
 linking to a separately built static library).
 
 Repository

src/beast/.gitignore

@@ -27,3 +27,4 @@ Builds/VisualStudio2012/Debug
 Builds/VisualStudio2012/Release
 project.xcworkspace
 modules/beast_cryptopp
+bin/

src/beast/.travis.yml

@@ -0,0 +1,26 @@
+language: cpp
+
+compiler:
+  - gcc
+  - clang
+before_install:
+  - sudo add-apt-repository -y ppa:ubuntu-toolchain-r/test
+  - sudo add-apt-repository -y ppa:boost-latest/ppa
+  - sudo apt-get update -qq
+  - sudo apt-get install -qq python-software-properties
+  - sudo apt-get install -qq g++-4.8
+  - sudo apt-get install -qq libboost1.55-all-dev 
+  - sudo apt-get install -qq libssl-dev
+  - sudo apt-get install -qq gcc-4.8
+  - sudo update-alternatives --install /usr/bin/gcc gcc /usr/bin/gcc-4.8 40 --slave /usr/bin/g++ g++ /usr/bin/g++-4.8
+  - sudo update-alternatives --set gcc /usr/bin/gcc-4.8
+#  - sudo apt-get -y install binutils-gold
+  - g++ -v
+  - clang -v
+script:
+  # Abort build on failure
+  - set -e
+  - scons 
+notifications:
+  email:
+    false

src/beast/BeastConfig.h

@@ -27,6 +27,19 @@
     @file BeastConfig.h
 */
 
+//------------------------------------------------------------------------------
+//
+// Unit Tests
+//
+//------------------------------------------------------------------------------
+
+/** Config: BEAST_NO_UNIT_TEST_INLINE
+    Prevents unit test definitions from being inserted into a global table.
+*/
+#ifndef BEAST_NO_UNIT_TEST_INLINE
+#define BEAST_NO_UNIT_TEST_INLINE 0
+#endif
+
 //------------------------------------------------------------------------------
 //
 // Diagnostics

src/beast/Builds/VisualStudio2013/Beast.props

@@ -1,22 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <ImportGroup Label="PropertySheets" />
-  <PropertyGroup Label="UserMacros">
-    <RepoDir>..\..</RepoDir>
-  </PropertyGroup>
-  <PropertyGroup />
-  <ItemDefinitionGroup>
-    <ClCompile>
-      <WarningLevel>Level4</WarningLevel>
-      <PreprocessorDefinitions>BEAST_COMPILING_STATIC_LIBARARY=1;_CRTDBG_MAP_ALLOC;_WIN32_WINNT=0x0600;_SCL_SECURE_NO_WARNINGS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <MultiProcessorCompilation>true</MultiProcessorCompilation>
-      <MinimalRebuild>false</MinimalRebuild>
-      <AdditionalIncludeDirectories>$(RepoDir)\config;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
-    </ClCompile>
-  </ItemDefinitionGroup>
-  <ItemGroup>
-    <BuildMacro Include="RepoDir">
-      <Value>$(RepoDir)</Value>
-    </BuildMacro>
-  </ItemGroup>
-</Project>

src/beast/CodingStyle.md

@@ -1,228 +0,0 @@
-Write code in a clear, self-documenting style but use comments where necessary.
-Use Test Driven Development. It encourages designing interfaces first, before implementation.
-Don't Repeat Yourself, <20>D.R.Y.<2E>. Put redundant code in a class so it can be re-used and unit tested.
-Expose as little of a class as possible. Prefer private over protected. Prefer protected over public. The smaller the interface footprint, the easier it is to write unit tests and comprehend the operation of the class. This is the Interface Segregation Principle.
-Use language constants (enum or static const) with descriptive names instead of hard-coded <20>magic numbers.<2E>
-Make classes depend on as few external classes or routines as possible. Ideally, no dependencies.
-Don't limit flexibility of parameters by forcing the caller to use specific types where general types would work.
-
---------------------------------------------------------------------------------
-
-# Coding Standards
-
-Coding standards used here are extreme strict and consistent. The style
-evolved gradually over the years, incorporating generally acknowledged
-best-practice C++ advice, experience, and personal preference.
-
-## Don't Repeat Yourself!
-
-The [Don't Repeat Yourself][1] principle summarises the essence of what it
-means to write good code, in all languages, at all levels.
-
-## Formatting
-
-The goal of source code formatting should always be to make things as easy to
-read as possible. White space is used to guide the eye so that details are not
-overlooked. Blank lines are used to separate code into "paragraphs."
-
-* No tab characters please.
-* Tab stops are set to 4 spaces.
-* Braces are indented in the [Allman style][2].
-* Always place a space before and after all binary operators,
-  especially assignments (`operator=`).
-* The `!` operator should always be followed by a space.
-* The `~` operator should be preceded by a space, but not followed by one.
-* The `++` and `--` operators should have no spaces between the operator and
-  the operand.
-* A space never appears before a comma, and always appears after a comma.
-* Always place a space before an opening parenthesis. One exception is if
-  the parentheses are empty.
-* Don't put spaces after a parenthesis. A typical member function call might
-  look like this: `foobar (1, 2, 3);`
-* In general, leave a blank line before an `if` statement.
-* In general, leave a blank line after a closing brace `}`.
-* Do not place code or comments on the same line as any opening or
-  closing brace.
-* Do not write `if` statements all-on-one-line. The exception to this is when
-  you've got a sequence of similar `if` statements, and are aligning them all
-  vertically to highlight their similarities.
-* In an `if-else` statement, if you surround one half of the statement with
-  braces, you also need to put braces around the other half, to match.
-* When writing a pointer type, use this spacing: `SomeObject* myObject`.
-  Technically, a more correct spacing would be `SomeObject *myObject`, but
-  it makes more sense for the asterisk to be grouped with the type name,
-  since being a pointer is part of the type, not the variable name. The only
-  time that this can lead to any problems is when you're declaring multiple
-  pointers of the same type in the same statement - which leads on to the next
-  rule:
-* When declaring multiple pointers, never do so in a single statement, e.g.
-  `SomeObject* p1, *p2;` - instead, always split them out onto separate lines
-  and write the type name again, to make it quite clear what's going on, and
-  avoid the danger of missing out any vital asterisks.
-* The previous point also applies to references, so always put the `&` next to
-  the type rather than the variable, e.g. `void foo (Thing const& thing)`. And
-  don't put a space on both sides of the `*` or `&` - always put a space after
-  it, but never before it.
-* The word `const` should be placed to the right of the thing that it modifies,
-  for consistency. For example `int const` refers to an int which is const.
-  `int const*` is a pointer to an int which is const. `int *const` is a const
-  pointer to an int.
-* Always place a space in between the template angle brackets and the type
-  name. Template code is already hard enough to read!
-
-## Naming conventions
-
-* Member variables and method names are written with camel-case, and never
-  begin with a capital letter.
-* Class names are also written in camel-case, but always begin with a capital
-  letter.
-* For global variables... well, you shouldn't have any, so it doesn't matter.
-* Class data members begin with `m_`, static data members begin with `s_`.
-  Global variables begin with `g_`. This is so the scope of the corresponding
-  declaration can be easily determined.
-* Avoid underscores in your names, especially leading or trailing underscores.
-  In particular, leading underscores should be avoided, as these are often used
-  in standard library code, so to use them in your own code looks quite jarring.
-* If you really have to write a macro for some reason, then make it all caps,
-  with underscores to separate the words. And obviously make sure that its name
-  is unlikely to clash with symbols used in other libraries or 3rd party code.
-
-## Types, const-correctness
-
-* If a method can (and should!) be const, make it const!
-* If a method definitely doesn't throw an exception (be careful!), mark it as
-  `noexcept`
-* When returning a temporary object, e.g. a String, the returned object should
-  be non-const, so that if the class has a C++11 move operator, it can be used.
-* If a local variable can be const, then make it const!
-* Remember that pointers can be const as well as primitives; For example, if
-  you have a `char*` whose contents are going to be altered, you may still be
-  able to make the pointer itself const, e.g. `char* const foobar = getFoobar();`.
-* Do not declare all your local variables at the top of a function or method
-  (i.e. in the old-fashioned C-style). Declare them at the last possible moment,
-  and give them as small a scope as possible.
-* Object parameters should be passed as `const&` wherever possible. Only
-  pass a parameter as a copy-by-value object if you really need to mutate
-  a local copy inside the method, and if making a local copy inside the method
-  would be difficult.
-* Use portable `for()` loop variable scoping (i.e. do not have multiple for
-  loops in the same scope that each re-declare the same variable name, as
-  this fails on older compilers)
-* When you're testing a pointer to see if it's null, never write
-  `if (myPointer)`. Always avoid that implicit cast-to-bool by writing it more
-  fully: `if (myPointer != nullptr)`. And likewise, never ever write
-  `if (! myPointer)`, instead always write `if (myPointer == nullptr)`.
-  It is more readable that way.
-* Avoid C-style casts except when converting between primitive numeric types.
-  Some people would say "avoid C-style casts altogether", but `static_cast` is
-  a bit unreadable when you just want to cast an `int` to a `float`. But
-  whenever a pointer is involved, or a non-primitive object, always use
-  `static_cast`. And when you're reinterpreting data, always use
-  `reinterpret_cast`.
-* Until C++ gets a universal 64-bit primitive type (part of the C++11
-  standard), it's best to stick to the `int64` and `uint64` typedefs.
-
-## Object lifetime and ownership
-
-* Absolutely do NOT use `delete`, `deleteAndZero`, etc. There are very very few
-  situations where you can't use a `ScopedPointer` or some other automatic
-  lifetime management class.
-* Do not use `new` unless there's no alternative. Whenever you type `new`, always
-  treat it as a failure to find a better solution. If a local variable can be
-  allocated on the stack rather than the heap, then always do so.
-* Do not ever use `new` or `malloc` to allocate a C++ array. Always use a
-  `HeapBlock` instead.
-* And just to make it doubly clear: Never use `malloc` or `calloc`.
-* If a parent object needs to create and own some kind of child object, always
-  use composition as your first choice. If that's not possible (e.g. if the
-  child needs a pointer to the parent for its constructor), then use a
-  `ScopedPointer`.
-* If possible, pass an object as a reference rather than a pointer. If possible,
-  make it a `const` reference.
-* Obviously avoid static and global values. Sometimes there's no alternative,
-  but if there is an alternative, then use it, no matter how much effort it
-  involves.
-* If allocating a local POD structure (e.g. an operating-system structure in
-  native code), and you need to initialise it with zeros, use the `= { 0 };`
-  syntax as your first choice for doing this. If for some reason that's not
-  appropriate, use the `zerostruct()` function, or in case that isn't suitable,
-  use `zeromem()`. Don't use `memset()`.
-
-## Classes
-
-* Declare a class's public section first, and put its constructors and
-  destructor first. Any protected items come next, and then private ones.
-* Use the most restrictive access-specifier possible for each member. Prefer
-  `private` over `protected`, and `protected` over `public`. Don't expose
-  things unnecessarily.
-* Preferred positioning for any inherited classes is to put them to the right
-  of the class name, vertically aligned, e.g.:
-        class Thing  : public Foo, 
-                       private Bar
-        {
-        }
-* Put a class's member variables (which should almost always be private, of course),
-  after all the public and protected method declarations.
-* Any private methods can go towards the end of the class, after the member
-  variables.
-* If your class does not have copy-by-value semantics, derive the class from
-  `Uncopyable`.
-* If your class is likely to be leaked, then derive your class from
-  `LeakChecked<>`.
-* Constructors that take a single parameter should be default be marked
-  `explicit`. Obviously there are cases where you do want implicit conversion,
-  but always think about it carefully before writing a non-explicit constructor.
-* Do not use `NULL`, `null`, or 0 for a null-pointer. And especially never use
-  '0L', which is particulary burdensome. Use `nullptr` instead - this is the
-  C++2011 standard, so get used to it. There's a fallback definition for `nullptr`
-  in Beast, so it's always possible to use it even if your compiler isn't yet
-  C++2011 compliant.
-* All the C++ 'guru' books and articles are full of excellent and detailed advice
-  on when it's best to use inheritance vs composition. If you're not already
-  familiar with the received wisdom in these matters, then do some reading!
-
-## Miscellaneous
-
-* Constrain the scope of identifiers to the smallest area that needs it. Consider
-  using nested classes or classes inside functions, if doing so will expose less
-  interface and implementation overall.
-* `goto` statements should not be used at all, even if the alternative is
-  more verbose code. The only exception is when implementing an algorithm in
-  a function as a state machine.
-* Don't use macros! OK, obviously there are many situations where they're the
-  right tool for the job, but treat them as a last resort. Certainly don't ever
-  use a macro just to hold a constant value or to perform any kind of function
-  that could have been done as a real inline function. And it goes without saying
-  that you should give them names which aren't going to clash with other code.
-  And `#undef` them after you've used them, if possible.
-* When using the `++` or `--` operators, never use post-increment if
-  pre-increment could be used instead. Although it doesn't matter for
-  primitive types, it's good practice to pre-increment since this can be
-  much more efficient for more complex objects. In particular, if you're
-  writing a for loop, always use pre-increment,
-  e.g. `for (int = 0; i < 10; ++i)`
-* Never put an "else" statement after a "return"! This is well-explained in the
-  LLVM coding standards...and a couple of other very good pieces of advice from
-  the LLVM standards are in there as well.
-* When getting a possibly-null pointer and using it only if it's non-null, limit
-  the scope of the pointer as much as possible - e.g. Do NOT do this:
-
-        Foo* f = getFoo ();
-        if (f != nullptr)
-            f->doSomething ();
-        // other code
-        f->doSomething ();  // oops! f may be null!
-
-  ..instead, prefer to write it like this, which reduces the scope of the
-  pointer, making it impossible to write code that accidentally uses a null
-  pointer:
-
-        if (Foo* f = getFoo ())
-            f->doSomethingElse ();
-
-        // f is out-of-scope here, so impossible to use it if it's null
-
-  (This also results in smaller, cleaner code)
-
-[1]: http://en.wikipedia.org/wiki/Don%27t_repeat_yourself
-[2]: http://en.wikipedia.org/wiki/Indent_style#Allman_style

src/beast/Doxyfile

@@ -102,7 +102,7 @@ INPUT_ENCODING         = UTF-8
 FILE_PATTERNS          =
 RECURSIVE              = YES
 EXCLUDE                = modules/beast_core/beast_core.h \
-                         modules/beast_core/beast_core.cpp \
+                         modules/beast_core/beast_core.unity.cpp \
                          modules/beast_basics/beast_basics.cpp \
                          modules/beast_basics/native \
                          modules/beast_basics/zip/zlib

src/beast/SConstruct

@@ -0,0 +1,139 @@
+from __future__ import absolute_import, division, print_function, unicode_literals
+
+import copy
+import itertools
+import ntpath
+import os
+import random
+import sys
+
+def add_beast_to_path():
+    python_home = os.path.join(os.getcwd(), 'python')
+    if python_home not in sys.path:
+        sys.path.append(python_home)
+
+add_beast_to_path()
+
+from beast.env.AddCommonFlags import add_common_flags
+from beast.env.AddUserEnv import add_user_env
+from beast.env import Print
+from beast.platform import GetEnvironment
+from beast.util import Boost
+from beast.util import File
+from beast.util import Tests
+
+VARIANT_DIRECTORIES = {
+    'beast': ('bin', 'beast'),
+    'modules': ('bin', 'modules'),
+}
+
+BOOST_LIBRARIES = '' #boost_system'
+MAIN_PROGRAM_FILE = 'beast/unit_test/tests/main.cpp'
+DOTFILE = '~/.scons'
+
+def main():
+    File.validate_libraries(Boost.LIBPATH, BOOST_LIBRARIES)
+    defaults = GetEnvironment.get_environment(ARGUMENTS)
+    working = copy.deepcopy(defaults)
+    add_common_flags(defaults)
+
+    add_user_env(working, DOTFILE)
+    add_common_flags(working)
+    Print.print_build_config(working, defaults)
+
+    env = Environment(**working)
+
+    for name, path in VARIANT_DIRECTORIES.items():
+        env.VariantDir(os.path.join(*path), name, duplicate=0)
+    env.Replace(PRINT_CMD_LINE_FUNC=Print.print_cmd_line)
+    #Tests.run_tests(env, MAIN_PROGRAM_FILE, '.', '.test.cpp')
+
+#main()
+
+#-------------------------------------------------------------------------------
+
+def is_unity(path):
+    b, e = os.path.splitext(path)
+    return os.path.splitext(b)[1] == '.unity' and e in ['.c', '.cpp']
+
+def files(base):
+    for parent, _, files in os.walk(base):
+        for path in files:
+            path = os.path.join(parent, path)
+            yield os.path.normpath(path)
+
+#-------------------------------------------------------------------------------
+
+'''
+/MP /GS /W3 /wd"4018" /wd"4244" /wd"4267" /Gy- /Zc:wchar_t
+/I"D:\lib\OpenSSL-Win64\include" /I"D:\lib\boost_1_55_0"
+/I"..\..\src\protobuf\src" /I"..\..\src\protobuf\vsprojects"
+/I"..\..\src\leveldb" /I"..\..\src\leveldb\include" /I"..\..\build\proto"
+/Zi /Gm- /Od /Fd"..\..\build\obj\VisualStudio2013\Debug.x64\vc120.pdb"
+/fp:precise /D "_CRTDBG_MAP_ALLOC" /D "WIN32" /D "_DEBUG" /D "_CONSOLE"
+/D "_VARIADIC_MAX=10" /D "_WIN32_WINNT=0x0600" /D "_SCL_SECURE_NO_WARNINGS"
+/D "_CRT_SECURE_NO_WARNINGS" /D "_MBCS" /errorReport:prompt /WX- /Zc:forScope
+/RTC1 /GR /Gd /MTd /openmp- /Fa"..\..\build\obj\VisualStudio2013\Debug.x64\"
+/EHa /nologo /Fo"..\..\build\obj\VisualStudio2013\Debug.x64\"
+/Fp"..\..\build\obj\VisualStudio2013\Debug.x64\rippled.pch" 
+'''
+
+# Path to this SConstruct file
+base_dir = Dir('#').srcnode().get_abspath()
+
+base_env = Environment(
+    tools = ['default', 'VSProject'],
+    CCCOMSTR = '',
+    CMDLINE_QUIET = 1,
+    CPPPATH = [
+        os.environ['BOOST_ROOT'],
+        os.environ['OPENSSL_ROOT']
+        ],
+    CPPDEFINES = [
+        '_WIN32_WINNT=0x6000']
+        )
+
+#base_env.Replace(PRINT_CMD_LINE_FUNC=Print.print_cmd_line)
+
+env = base_env
+
+bin_dir = os.path.join(base_dir, 'bin')
+
+srcs = filter(is_unity, list(files('beast')) + list(files('modules')))
+for variant in ['Debug']: #, 'Release']:
+    for platform in ['Win32']:
+        #env = base_env.Clone()
+        #env.Replace(PRINT_CMD_LINE_FUNC=Print.print_cmd_line)
+        variant_dir = os.path.join(bin_dir, variant + '.' + platform)
+        env.VariantDir(os.path.join(variant_dir, 'beast'), 'beast', duplicate=0)
+        env.VariantDir(os.path.join(variant_dir, 'modules'), 'modules', duplicate=0)
+        env.Append(CCFLAGS=[
+            '/EHsc',
+            '/bigobj',
+            '/Fd${TARGET}.pdb'
+            ])
+        if variant == 'Debug':
+            env.Append(CCFLAGS=[
+                '/MTd',
+                '/Od',
+                '/Zi'
+                ])
+        else:
+            env.Append(CCFLAGS=[
+                '/MT',
+                '/Ox'
+                ])
+        variant_srcs = [os.path.join(variant_dir, os.path.relpath(f, base_dir)) for f in srcs]
+
+        beast = env.StaticLibrary(
+            target = os.path.join(variant_dir, 'beast.lib'),
+            source = variant_srcs)
+
+env.VSProject (
+    'out',
+    buildtarget = beast,
+    source = filter(is_unity, list(files('beast')) + list(files('modules'))))
+
+env.Default ('out.vcxproj')
+#env.Default (os.path.join(bin_dir,'Debug.Win32', 'beast.lib'))
+

src/beast/TODO.txt

@@ -1,72 +0,0 @@
---------------------------------------------------------------------------------
-BEAST TODO
---------------------------------------------------------------------------------
-
-- Use SemanticVersion for beast version numbers to replace BEAST_VERSION
-
-- add support for a __PRETTY_FUNCTION__ equivalent for all environments
-
-- add expectThrow() to UnitTest, where it expects an exception
-
-- Import secp256k1 from sipa
-
-- Set sqlite thread safety model to '2' in beast_sqlite
-
-- Document and rename all the sqdb files and classes
-
-- Specialize UnsignedInteger<> for peformance in the storage format
-
-- Rename HeapBlock routines to not conflict with _CRTDBG_MAP_ALLOC macros
-
-- Design a WeakPtr / SharedPtr / SharedObject intrusive system
-
-- Implement beast::Bimap?
-
-- Use Bimap for storage in the DeadlineTimer::Manager, to support
-  thousands of timers.
-
-- Think about adding a shouldStop bool to InterruptibleThread, along
-  with a shouldStop () function returning bool, and a stop() method.
-
-- Make OwnedArray add routines return a pointer instead of reference
-
-- Tidy up CacheLine, MemoryAlignment
-
-- Remove anything having to do with DLL builds like
-  BEAST_DLL, BEAST_DLL_BUILD, BEAST_DISABLE_DLL_ALLOCATORS
-
-- Fix FifoFreeStoreWithTLS reference counting bug
-
-- Implement a reasonable substitute for boost's thread_local_storage
-
-- Think about doing away with BEAST_CALLTYPE and BEAST_API
-
-- Decide if headers should just include BeastConfig.h instead of making the
-  host program do it.
-
-- Rename malloc/calloc JUCE members that conflict with the debug CRT from MSVC
-
-- Reformat every Doxygen comment
-- Fix Doxygen metatags
-- update Beast Doxyfile
-
-- Rename include guards to boost style, e.g. BEAST_THROW_H_INCLUDED
-
-- Clean up CacheLine, StaticObject
-
-- Clean up ConcurrentObject
-
-- Rename SharedData to SharedState or something?
-
-- Figure out what to do with ReadWriteLock, and NamedPipe which uses it?
-
-- Put BEAST_PUBLIC_FUNCTION in front of all loose functions
-
-- restructure the repo sources to look like this:
-  /Source/beast/beast_core/beast_core.h
-  etc...
-- Put the BeastConfig.h at the root of the repo.
-- Make sure the template BeastConfig.h is included in the Doxyfile
-
-- Implement robust key/value database with bulk write
-

src/beast/beast/Arithmetic.h

@@ -24,10 +24,12 @@
 #ifndef BEAST_ARITHMETIC_H_INCLUDED
 #define BEAST_ARITHMETIC_H_INCLUDED
 
-#include "Config.h"
-#include "CStdInt.h"
+#include <beast/Config.h>
+
+#include <beast/utility/noexcept.h>
 
 #include <cmath>
+#include <cstdint>
 #include <algorithm>
 
 namespace beast {
@@ -195,12 +197,6 @@ inline bool isPositiveAndNotGreaterThan (const int valueToTest, const int upperL
 }
 
 //==============================================================================
-/** Handy function to swap two values. */
-template <typename Type>
-inline void swapVariables (Type& variable1, Type& variable2)
-{
-    std::swap (variable1, variable2);
-}
 
 /** Handy function for getting the number of elements in a simple const C array.
     E.g.
@@ -218,54 +214,12 @@ int numElementsInArray (Type (&array)[N])
     return N;
 }
 
-//==============================================================================
-// Some useful maths functions that aren't always present with all compilers and build settings.
-
-/** Using beast_hypot is easier than dealing with the different types of hypot function
-    that are provided by the various platforms and compilers. */
-template <typename Type>
-inline Type beast_hypot (Type a, Type b) noexcept
-{
-   #if BEAST_MSVC
-    return static_cast <Type> (_hypot (a, b));
-   #else
-    return static_cast <Type> (hypot (a, b));
-   #endif
-}
-
 /** 64-bit abs function. */
-inline int64 abs64 (const int64 n) noexcept
+inline std::int64_t abs64 (const std::int64_t n) noexcept
 {
     return (n >= 0) ? n : -n;
 }
 
-//==============================================================================
-/** A predefined value for Pi, at double-precision.
-    @see float_Pi
-*/
-const double  double_Pi  = 3.1415926535897932384626433832795;
-
-/** A predefined value for Pi, at single-precision.
-    @see double_Pi
-*/
-const float   float_Pi   = 3.14159265358979323846f;
-
-
-//==============================================================================
-/** The isfinite() method seems to vary between platforms, so this is a
-    platform-independent function for it.
-*/
-template <typename FloatingPointType>
-inline bool beast_isfinite (FloatingPointType value)
-{
-   #if BEAST_WINDOWS
-    return _finite (value);
-   #elif BEAST_ANDROID
-    return isfinite (value);
-   #else
-    return std::isfinite (value);
-   #endif
-}
 
 //==============================================================================
 #if BEAST_MSVC
@@ -309,149 +263,6 @@ inline int roundToInt (const FloatType value) noexcept
  #pragma optimize ("", on)  // resets optimisations to the project defaults
 #endif
 
-/** Fast floating-point-to-integer conversion.
-
-    This is a slightly slower and slightly more accurate version of roundDoubleToInt(). It works
-    fine for values above zero, but negative numbers are rounded the wrong way.
-*/
-inline int roundToIntAccurate (const double value) noexcept
-{
-   #ifdef __INTEL_COMPILER
-    #pragma float_control (pop)
-   #endif
-
-    return roundToInt (value + 1.5e-8);
-}
-
-/** Fast floating-point-to-integer conversion.
-
-    This is faster than using the normal c++ cast to convert a double to an int, and
-    it will round the value to the nearest integer, rather than rounding it down
-    like the normal cast does.
-
-    Note that this routine gets its speed at the expense of some accuracy, and when
-    rounding values whose floating point component is exactly 0.5, odd numbers and
-    even numbers will be rounded up or down differently. For a more accurate conversion,
-    see roundDoubleToIntAccurate().
-*/
-inline int roundDoubleToInt (const double value) noexcept
-{
-    return roundToInt (value);
-}
-
-/** Fast floating-point-to-integer conversion.
-
-    This is faster than using the normal c++ cast to convert a float to an int, and
-    it will round the value to the nearest integer, rather than rounding it down
-    like the normal cast does.
-
-    Note that this routine gets its speed at the expense of some accuracy, and when
-    rounding values whose floating point component is exactly 0.5, odd numbers and
-    even numbers will be rounded up or down differently.
-*/
-inline int roundFloatToInt (const float value) noexcept
-{
-    return roundToInt (value);
-}
-
-//==============================================================================
-/** Returns true if the specified integer is a power-of-two.
-*/
-template <typename IntegerType>
-bool isPowerOfTwo (IntegerType value)
-{
-   return (value & (value - 1)) == 0;
-}
-
-/** Returns the smallest power-of-two which is equal to or greater than the given integer.
-*/
-inline int nextPowerOfTwo (int n) noexcept
-{
-    --n;
-    n |= (n >> 1);
-    n |= (n >> 2);
-    n |= (n >> 4);
-    n |= (n >> 8);
-    n |= (n >> 16);
-    return n + 1;
-}
-
-/** Performs a modulo operation, but can cope with the dividend being negative.
-    The divisor must be greater than zero.
-*/
-template <typename IntegerType>
-IntegerType negativeAwareModulo (IntegerType dividend, const IntegerType divisor) noexcept
-{
-    bassert (divisor > 0);
-    dividend %= divisor;
-    return (dividend < 0) ? (dividend + divisor) : dividend;
-}
-
-//==============================================================================
-#if (BEAST_INTEL && BEAST_32BIT) || defined (DOXYGEN)
- /** This macro can be applied to a float variable to check whether it contains a denormalised
-     value, and to normalise it if necessary.
-     On CPUs that aren't vulnerable to denormalisation problems, this will have no effect.
- */
- #define BEAST_UNDENORMALISE(x)   x += 1.0f; x -= 1.0f;
-#else
- #define BEAST_UNDENORMALISE(x)
-#endif
-
-//==============================================================================
-/** This namespace contains a few template classes for helping work out class type variations.
-*/
-namespace TypeHelpers
-{
-   #if BEAST_VC8_OR_EARLIER
-    #define PARAMETER_TYPE(type) const type&
-   #else
-    /** The ParameterType struct is used to find the best type to use when passing some kind
-        of object as a parameter.
-
-        Of course, this is only likely to be useful in certain esoteric template situations.
-
-        Because "typename TypeHelpers::ParameterType<SomeClass>::type" is a bit of a mouthful, there's
-        a PARAMETER_TYPE(SomeClass) macro that you can use to get the same effect.
-
-        E.g. "myFunction (PARAMETER_TYPE (int), PARAMETER_TYPE (MyObject))"
-        would evaluate to "myfunction (int, const MyObject&)", keeping any primitive types as
-        pass-by-value, but passing objects as a const reference, to avoid copying.
-    */
-    template <typename Type> struct ParameterType                   { typedef const Type& type; };
-
-   #if ! DOXYGEN
-    template <typename Type> struct ParameterType <Type&>           { typedef Type& type; };
-    template <typename Type> struct ParameterType <Type*>           { typedef Type* type; };
-    template <>              struct ParameterType <char>            { typedef char type; };
-    template <>              struct ParameterType <unsigned char>   { typedef unsigned char type; };
-    template <>              struct ParameterType <short>           { typedef short type; };
-    template <>              struct ParameterType <unsigned short>  { typedef unsigned short type; };
-    template <>              struct ParameterType <int>             { typedef int type; };
-    template <>              struct ParameterType <unsigned int>    { typedef unsigned int type; };
-    template <>              struct ParameterType <long>            { typedef long type; };
-    template <>              struct ParameterType <unsigned long>   { typedef unsigned long type; };
-    template <>              struct ParameterType <int64>           { typedef int64 type; };
-    template <>              struct ParameterType <uint64>          { typedef uint64 type; };
-    template <>              struct ParameterType <bool>            { typedef bool type; };
-    template <>              struct ParameterType <float>           { typedef float type; };
-    template <>              struct ParameterType <double>          { typedef double type; };
-   #endif
-
-    /** A helpful macro to simplify the use of the ParameterType template.
-        @see ParameterType
-    */
-    #define PARAMETER_TYPE(a)    typename TypeHelpers::ParameterType<a>::type
-   #endif
-
-
-    /** These templates are designed to take a type, and if it's a double, they return a double
-        type; for anything else, they return a float type.
-    */
-    template <typename Type> struct SmallestFloatType             { typedef float  type; };
-    template <>              struct SmallestFloatType <double>    { typedef double type; };
-}
-
 }
 
 #endif

src/beast/beast/Atomic.h

@@ -24,9 +24,12 @@
 #ifndef BEAST_ATOMIC_H_INCLUDED
 #define BEAST_ATOMIC_H_INCLUDED
 
-#include "Config.h"
-#include "CStdInt.h"
-#include "StaticAssert.h"
+#include <beast/Config.h>
+#include <beast/StaticAssert.h>
+
+#include <beast/utility/noexcept.h>
+
+#include <cstdint>
 
 namespace beast {
 
@@ -156,10 +159,10 @@ private:
     template <typename Dest, typename Source>
     static inline Dest castTo (Source value) noexcept { union { Dest d; Source s; } u; u.s = value; return u.d; }
 
-    static inline Type castFrom32Bit (int32 value) noexcept { return castTo <Type, int32> (value); }
-    static inline Type castFrom64Bit (int64 value) noexcept { return castTo <Type, int64> (value); }
-    static inline int32 castTo32Bit (Type value) noexcept { return castTo <int32, Type> (value); }
-    static inline int64 castTo64Bit (Type value) noexcept { return castTo <int64, Type> (value); }
+    static inline Type castFrom32Bit (std::int32_t value) noexcept { return castTo <Type, std::int32_t> (value); }
+    static inline Type castFrom64Bit (std::int64_t value) noexcept { return castTo <Type, std::int64_t> (value); }
+    static inline std::int32_t castTo32Bit (Type value) noexcept { return castTo <std::int32_t, Type> (value); }
+    static inline std::int64_t castTo64Bit (Type value) noexcept { return castTo <std::int64_t, Type> (value); }
 
 
     Type operator++ (int); // better to just use pre-increment with atomics..
@@ -172,14 +175,14 @@ private:
         return sizeof (ValueType) == 1 ? (ValueType) -(signed char) n
             : (sizeof (ValueType) == 2 ? (ValueType) -(short) n
             : (sizeof (ValueType) == 4 ? (ValueType) -(int) n
-            : ((ValueType) -(int64) n)));
+            : ((ValueType) -(std::int64_t) n)));
     }
 
     /** This templated negate function will negate pointers as well as integers */
     template <typename PointerType>
     inline PointerType* negateValue (PointerType* n) noexcept
     {
-        return reinterpret_cast <PointerType*> (-reinterpret_cast <pointer_sized_int> (n));
+        return reinterpret_cast <PointerType*> (-reinterpret_cast <std::intptr_t> (n));
     }
 };
 
@@ -272,14 +275,14 @@ template <typename Type>
 inline Type Atomic<Type>::get() const noexcept
 {
   #if BEAST_ATOMICS_MAC
-    return sizeof (Type) == 4 ? castFrom32Bit ((int32) OSAtomicAdd32Barrier ((int32_t) 0, (BEAST_MAC_ATOMICS_VOLATILE int32_t*) &value))
-                              : castFrom64Bit ((int64) OSAtomicAdd64Barrier ((int64_t) 0, (BEAST_MAC_ATOMICS_VOLATILE int64_t*) &value));
+    return sizeof (Type) == 4 ? castFrom32Bit ((std::int32_t) OSAtomicAdd32Barrier ((int32_t) 0, (BEAST_MAC_ATOMICS_VOLATILE int32_t*) &value))
+                              : castFrom64Bit ((std::int64_t) OSAtomicAdd64Barrier ((int64_t) 0, (BEAST_MAC_ATOMICS_VOLATILE int64_t*) &value));
   #elif BEAST_ATOMICS_WINDOWS
-    return sizeof (Type) == 4 ? castFrom32Bit ((int32) beast_InterlockedExchangeAdd ((volatile long*) &value, (long) 0))
-                              : castFrom64Bit ((int64) beast_InterlockedExchangeAdd64 ((volatile __int64*) &value, (__int64) 0));
+    return sizeof (Type) == 4 ? castFrom32Bit ((std::int32_t) beast_InterlockedExchangeAdd ((volatile long*) &value, (long) 0))
+                              : castFrom64Bit ((std::int64_t) beast_InterlockedExchangeAdd64 ((volatile __int64*) &value, (__int64) 0));
   #elif BEAST_ATOMICS_GCC
-    return sizeof (Type) == 4 ? castFrom32Bit ((int32) __sync_add_and_fetch ((volatile int32*) &value, 0))
-                              : castFrom64Bit ((int64) __sync_add_and_fetch ((volatile int64*) &value, 0));
+    return sizeof (Type) == 4 ? castFrom32Bit ((std::int32_t) __sync_add_and_fetch ((volatile std::int32_t*) &value, 0))
+                              : castFrom64Bit ((std::int64_t) __sync_add_and_fetch ((volatile std::int64_t*) &value, 0));
   #endif
 }
 
@@ -291,8 +294,8 @@ inline Type Atomic<Type>::exchange (const Type newValue) noexcept
     while (! compareAndSetBool (newValue, currentVal)) { currentVal = value; }
     return currentVal;
   #elif BEAST_ATOMICS_WINDOWS
-    return sizeof (Type) == 4 ? castFrom32Bit ((int32) beast_InterlockedExchange ((volatile long*) &value, (long) castTo32Bit (newValue)))
-                              : castFrom64Bit ((int64) beast_InterlockedExchange64 ((volatile __int64*) &value, (__int64) castTo64Bit (newValue)));
+    return sizeof (Type) == 4 ? castFrom32Bit ((std::int32_t) beast_InterlockedExchange ((volatile long*) &value, (long) castTo32Bit (newValue)))
+                              : castFrom64Bit ((std::int64_t) beast_InterlockedExchange64 ((volatile __int64*) &value, (__int64) castTo64Bit (newValue)));
   #endif
 }
 
@@ -377,8 +380,8 @@ inline bool Atomic<Type>::compareAndSetBool (const Type newValue, const Type val
   #elif BEAST_ATOMICS_WINDOWS
     return compareAndSetValue (newValue, valueToCompare) == valueToCompare;
   #elif BEAST_ATOMICS_GCC
-    return sizeof (Type) == 4 ? __sync_bool_compare_and_swap ((volatile int32*) &value, castTo32Bit (valueToCompare), castTo32Bit (newValue))
-                              : __sync_bool_compare_and_swap ((volatile int64*) &value, castTo64Bit (valueToCompare), castTo64Bit (newValue));
+    return sizeof (Type) == 4 ? __sync_bool_compare_and_swap ((volatile std::int32_t*) &value, castTo32Bit (valueToCompare), castTo32Bit (newValue))
+                              : __sync_bool_compare_and_swap ((volatile std::int64_t*) &value, castTo64Bit (valueToCompare), castTo64Bit (newValue));
   #endif
 }
 
@@ -397,11 +400,11 @@ inline Type Atomic<Type>::compareAndSetValue (const Type newValue, const Type va
     }
 
   #elif BEAST_ATOMICS_WINDOWS
-    return sizeof (Type) == 4 ? castFrom32Bit ((int32) beast_InterlockedCompareExchange ((volatile long*) &value, (long) castTo32Bit (newValue), (long) castTo32Bit (valueToCompare)))
-                              : castFrom64Bit ((int64) beast_InterlockedCompareExchange64 ((volatile __int64*) &value, (__int64) castTo64Bit (newValue), (__int64) castTo64Bit (valueToCompare)));
+    return sizeof (Type) == 4 ? castFrom32Bit ((std::int32_t) beast_InterlockedCompareExchange ((volatile long*) &value, (long) castTo32Bit (newValue), (long) castTo32Bit (valueToCompare)))
+                              : castFrom64Bit ((std::int64_t) beast_InterlockedCompareExchange64 ((volatile __int64*) &value, (__int64) castTo64Bit (newValue), (__int64) castTo64Bit (valueToCompare)));
   #elif BEAST_ATOMICS_GCC
-    return sizeof (Type) == 4 ? castFrom32Bit ((int32) __sync_val_compare_and_swap ((volatile int32*) &value, castTo32Bit (valueToCompare), castTo32Bit (newValue)))
-                              : castFrom64Bit ((int64) __sync_val_compare_and_swap ((volatile int64*) &value, castTo64Bit (valueToCompare), castTo64Bit (newValue)));
+    return sizeof (Type) == 4 ? castFrom32Bit ((std::int32_t) __sync_val_compare_and_swap ((volatile std::int32_t*) &value, castTo32Bit (valueToCompare), castTo32Bit (newValue)))
+                              : castFrom64Bit ((std::int64_t) __sync_val_compare_and_swap ((volatile std::int64_t*) &value, castTo64Bit (valueToCompare), castTo64Bit (newValue)));
   #endif
 }
 

src/beast/beast/Boost.h

@@ -22,6 +22,6 @@
 
 // These classes require boost in order to be used.
 
-#include "boost/ErrorCode.h"
+#include <beast/boost/ErrorCode.h>
 
 #endif

src/beast/beast/ByteOrder.h

@@ -24,9 +24,10 @@
 #ifndef BEAST_BYTEORDER_H_INCLUDED
 #define BEAST_BYTEORDER_H_INCLUDED
 
-#include "Config.h"
-#include "CStdInt.h"
-#include "Uncopyable.h"
+#include <beast/Config.h>
+#include <beast/Uncopyable.h>
+
+#include <cstdint>
 
 namespace beast {
 
@@ -39,51 +40,51 @@ class ByteOrder : public Uncopyable
 public:
     //==============================================================================
     /** Swaps the upper and lower bytes of a 16-bit integer. */
-    static uint16 swap (uint16 value);
+    static std::uint16_t swap (std::uint16_t value);
 
     /** Reverses the order of the 4 bytes in a 32-bit integer. */
-    static uint32 swap (uint32 value);
+    static std::uint32_t swap (std::uint32_t value);
 
     /** Reverses the order of the 8 bytes in a 64-bit integer. */
-    static uint64 swap (uint64 value);
+    static std::uint64_t swap (std::uint64_t value);
 
     //==============================================================================
     /** Swaps the byte order of a 16-bit int if the CPU is big-endian */
-    static uint16 swapIfBigEndian (uint16 value);
+    static std::uint16_t swapIfBigEndian (std::uint16_t value);
 
     /** Swaps the byte order of a 32-bit int if the CPU is big-endian */
-    static uint32 swapIfBigEndian (uint32 value);
+    static std::uint32_t swapIfBigEndian (std::uint32_t value);
 
     /** Swaps the byte order of a 64-bit int if the CPU is big-endian */
-    static uint64 swapIfBigEndian (uint64 value);
+    static std::uint64_t swapIfBigEndian (std::uint64_t value);
 
     /** Swaps the byte order of a 16-bit int if the CPU is little-endian */
-    static uint16 swapIfLittleEndian (uint16 value);
+    static std::uint16_t swapIfLittleEndian (std::uint16_t value);
 
     /** Swaps the byte order of a 32-bit int if the CPU is little-endian */
-    static uint32 swapIfLittleEndian (uint32 value);
+    static std::uint32_t swapIfLittleEndian (std::uint32_t value);
 
     /** Swaps the byte order of a 64-bit int if the CPU is little-endian */
-    static uint64 swapIfLittleEndian (uint64 value);
+    static std::uint64_t swapIfLittleEndian (std::uint64_t value);
 
     //==============================================================================
     /** Turns 2 bytes into a little-endian integer. */
-    static uint16 littleEndianShort (const void* bytes);
+    static std::uint16_t littleEndianShort (const void* bytes);
 
     /** Turns 4 bytes into a little-endian integer. */
-    static uint32 littleEndianInt (const void* bytes);
+    static std::uint32_t littleEndianInt (const void* bytes);
 
     /** Turns 4 bytes into a little-endian integer. */
-    static uint64 littleEndianInt64 (const void* bytes);
+    static std::uint64_t littleEndianInt64 (const void* bytes);
 
     /** Turns 2 bytes into a big-endian integer. */
-    static uint16 bigEndianShort (const void* bytes);
+    static std::uint16_t bigEndianShort (const void* bytes);
 
     /** Turns 4 bytes into a big-endian integer. */
-    static uint32 bigEndianInt (const void* bytes);
+    static std::uint32_t bigEndianInt (const void* bytes);
 
     /** Turns 4 bytes into a big-endian integer. */
-    static uint64 bigEndianInt64 (const void* bytes);
+    static std::uint64_t bigEndianInt64 (const void* bytes);
 
     //==============================================================================
     /** Converts 3 little-endian bytes into a signed 24-bit value (which is sign-extended to 32 bits). */
@@ -111,16 +112,16 @@ private:
  #pragma intrinsic (_byteswap_ulong)
 #endif
 
-inline uint16 ByteOrder::swap (uint16 n)
+inline std::uint16_t ByteOrder::swap (std::uint16_t n)
 {
    #if BEAST_USE_INTRINSICSxxx // agh - the MS compiler has an internal error when you try to use this intrinsic!
-    return static_cast <uint16> (_byteswap_ushort (n));
+    return static_cast <std::uint16_t> (_byteswap_ushort (n));
    #else
-    return static_cast <uint16> ((n << 8) | (n >> 8));
+    return static_cast <std::uint16_t> ((n << 8) | (n >> 8));
    #endif
 }
 
-inline uint32 ByteOrder::swap (uint32 n)
+inline std::uint32_t ByteOrder::swap (std::uint32_t n)
 {
    #if BEAST_MAC || BEAST_IOS
     return OSSwapInt32 (n);
@@ -143,48 +144,48 @@ inline uint32 ByteOrder::swap (uint32 n)
    #endif
 }
 
-inline uint64 ByteOrder::swap (uint64 value)
+inline std::uint64_t ByteOrder::swap (std::uint64_t value)
 {
    #if BEAST_MAC || BEAST_IOS
     return OSSwapInt64 (value);
    #elif BEAST_USE_INTRINSICS
     return _byteswap_uint64 (value);
    #else
-    return (((int64) swap ((uint32) value)) << 32) | swap ((uint32) (value >> 32));
+    return (((std::int64_t) swap ((std::uint32_t) value)) << 32) | swap ((std::uint32_t) (value >> 32));
    #endif
 }
 
 #if BEAST_LITTLE_ENDIAN
- inline uint16 ByteOrder::swapIfBigEndian (const uint16 v)                                  { return v; }
- inline uint32 ByteOrder::swapIfBigEndian (const uint32 v)                                  { return v; }
- inline uint64 ByteOrder::swapIfBigEndian (const uint64 v)                                  { return v; }
- inline uint16 ByteOrder::swapIfLittleEndian (const uint16 v)                               { return swap (v); }
- inline uint32 ByteOrder::swapIfLittleEndian (const uint32 v)                               { return swap (v); }
- inline uint64 ByteOrder::swapIfLittleEndian (const uint64 v)                               { return swap (v); }
- inline uint16 ByteOrder::littleEndianShort (const void* const bytes)                       { return *static_cast <const uint16*> (bytes); }
- inline uint32 ByteOrder::littleEndianInt (const void* const bytes)                         { return *static_cast <const uint32*> (bytes); }
- inline uint64 ByteOrder::littleEndianInt64 (const void* const bytes)                       { return *static_cast <const uint64*> (bytes); }
- inline uint16 ByteOrder::bigEndianShort (const void* const bytes)                          { return swap (*static_cast <const uint16*> (bytes)); }
- inline uint32 ByteOrder::bigEndianInt (const void* const bytes)                            { return swap (*static_cast <const uint32*> (bytes)); }
- inline uint64 ByteOrder::bigEndianInt64 (const void* const bytes)                          { return swap (*static_cast <const uint64*> (bytes)); }
+ inline std::uint16_t ByteOrder::swapIfBigEndian (const std::uint16_t v)                                  { return v; }
+ inline std::uint32_t ByteOrder::swapIfBigEndian (const std::uint32_t v)                                  { return v; }
+ inline std::uint64_t ByteOrder::swapIfBigEndian (const std::uint64_t v)                                  { return v; }
+ inline std::uint16_t ByteOrder::swapIfLittleEndian (const std::uint16_t v)                               { return swap (v); }
+ inline std::uint32_t ByteOrder::swapIfLittleEndian (const std::uint32_t v)                               { return swap (v); }
+ inline std::uint64_t ByteOrder::swapIfLittleEndian (const std::uint64_t v)                               { return swap (v); }
+ inline std::uint16_t ByteOrder::littleEndianShort (const void* const bytes)                       { return *static_cast <const std::uint16_t*> (bytes); }
+ inline std::uint32_t ByteOrder::littleEndianInt (const void* const bytes)                         { return *static_cast <const std::uint32_t*> (bytes); }
+ inline std::uint64_t ByteOrder::littleEndianInt64 (const void* const bytes)                       { return *static_cast <const std::uint64_t*> (bytes); }
+ inline std::uint16_t ByteOrder::bigEndianShort (const void* const bytes)                          { return swap (*static_cast <const std::uint16_t*> (bytes)); }
+ inline std::uint32_t ByteOrder::bigEndianInt (const void* const bytes)                            { return swap (*static_cast <const std::uint32_t*> (bytes)); }
+ inline std::uint64_t ByteOrder::bigEndianInt64 (const void* const bytes)                          { return swap (*static_cast <const std::uint64_t*> (bytes)); }
  inline bool ByteOrder::isBigEndian()                                                       { return false; }
 #else
- inline uint16 ByteOrder::swapIfBigEndian (const uint16 v)                                  { return swap (v); }
- inline uint32 ByteOrder::swapIfBigEndian (const uint32 v)                                  { return swap (v); }
- inline uint64 ByteOrder::swapIfBigEndian (const uint64 v)                                  { return swap (v); }
- inline uint16 ByteOrder::swapIfLittleEndian (const uint16 v)                               { return v; }
- inline uint32 ByteOrder::swapIfLittleEndian (const uint32 v)                               { return v; }
- inline uint64 ByteOrder::swapIfLittleEndian (const uint64 v)                               { return v; }
- inline uint32 ByteOrder::littleEndianInt (const void* const bytes)                         { return swap (*static_cast <const uint32*> (bytes)); }
- inline uint16 ByteOrder::littleEndianShort (const void* const bytes)                       { return swap (*static_cast <const uint16*> (bytes)); }
- inline uint16 ByteOrder::bigEndianShort (const void* const bytes)                          { return *static_cast <const uint16*> (bytes); }
- inline uint32 ByteOrder::bigEndianInt (const void* const bytes)                            { return *static_cast <const uint32*> (bytes); }
- inline uint64 ByteOrder::bigEndianInt64 (const void* const bytes)                          { return *static_cast <const uint64*> (bytes); }
+ inline std::uint16_t ByteOrder::swapIfBigEndian (const std::uint16_t v)                                  { return swap (v); }
+ inline std::uint32_t ByteOrder::swapIfBigEndian (const std::uint32_t v)                                  { return swap (v); }
+ inline std::uint64_t ByteOrder::swapIfBigEndian (const std::uint64_t v)                                  { return swap (v); }
+ inline std::uint16_t ByteOrder::swapIfLittleEndian (const std::uint16_t v)                               { return v; }
+ inline std::uint32_t ByteOrder::swapIfLittleEndian (const std::uint32_t v)                               { return v; }
+ inline std::uint64_t ByteOrder::swapIfLittleEndian (const std::uint64_t v)                               { return v; }
+ inline std::uint32_t ByteOrder::littleEndianInt (const void* const bytes)                         { return swap (*static_cast <const std::uint32_t*> (bytes)); }
+ inline std::uint16_t ByteOrder::littleEndianShort (const void* const bytes)                       { return swap (*static_cast <const std::uint16_t*> (bytes)); }
+ inline std::uint16_t ByteOrder::bigEndianShort (const void* const bytes)                          { return *static_cast <const std::uint16_t*> (bytes); }
+ inline std::uint32_t ByteOrder::bigEndianInt (const void* const bytes)                            { return *static_cast <const std::uint32_t*> (bytes); }
+ inline std::uint64_t ByteOrder::bigEndianInt64 (const void* const bytes)                          { return *static_cast <const std::uint64_t*> (bytes); }
  inline bool ByteOrder::isBigEndian()                                                       { return true; }
 #endif
 
-inline int  ByteOrder::littleEndian24Bit (const char* const bytes)                          { return (((int) bytes[2]) << 16) | (((int) (uint8) bytes[1]) << 8) | ((int) (uint8) bytes[0]); }
-inline int  ByteOrder::bigEndian24Bit (const char* const bytes)                             { return (((int) bytes[0]) << 16) | (((int) (uint8) bytes[1]) << 8) | ((int) (uint8) bytes[2]); }
+inline int  ByteOrder::littleEndian24Bit (const char* const bytes)                          { return (((int) bytes[2]) << 16) | (((int) (std::uint8_t) bytes[1]) << 8) | ((int) (std::uint8_t) bytes[0]); }
+inline int  ByteOrder::bigEndian24Bit (const char* const bytes)                             { return (((int) bytes[0]) << 16) | (((int) (std::uint8_t) bytes[1]) << 8) | ((int) (std::uint8_t) bytes[2]); }
 inline void ByteOrder::littleEndian24BitToChars (const int value, char* const destBytes)    { destBytes[0] = (char)(value & 0xff); destBytes[1] = (char)((value >> 8) & 0xff); destBytes[2] = (char)((value >> 16) & 0xff); }
 inline void ByteOrder::bigEndian24BitToChars (const int value, char* const destBytes)       { destBytes[0] = (char)((value >> 16) & 0xff); destBytes[1] = (char)((value >> 8) & 0xff); destBytes[2] = (char)(value & 0xff); }
 
@@ -211,29 +212,29 @@ struct SwapBytes
 // Specializations for signed integers
 
 template <>
-struct SwapBytes <int16>
+struct SwapBytes <std::int16_t>
 {
-    inline int16 operator() (int16 value) const noexcept 
+    inline std::int16_t operator() (std::int16_t value) const noexcept 
     {
-        return static_cast <int16> (ByteOrder::swap (static_cast <uint16> (value)));
+        return static_cast <std::int16_t> (ByteOrder::swap (static_cast <std::uint16_t> (value)));
     }
 };
 
 template <>
-struct SwapBytes <int32>
+struct SwapBytes <std::int32_t>
 {
-    inline int32 operator() (int32 value) const noexcept 
+    inline std::int32_t operator() (std::int32_t value) const noexcept 
     {
-        return static_cast <int32> (ByteOrder::swap (static_cast <uint32> (value)));
+        return static_cast <std::int32_t> (ByteOrder::swap (static_cast <std::uint32_t> (value)));
     }
 };
 
 template <>
-struct SwapBytes <int64>
+struct SwapBytes <std::int64_t>
 {
-    inline int64 operator() (int64 value) const noexcept 
+    inline std::int64_t operator() (std::int64_t value) const noexcept 
     {
-        return static_cast <int64> (ByteOrder::swap (static_cast <uint64> (value)));
+        return static_cast <std::int64_t> (ByteOrder::swap (static_cast <std::uint64_t> (value)));
     }
 };
 

src/beast/beast/CStdInt.h

@@ -1,88 +0,0 @@
-//------------------------------------------------------------------------------
-/*
-    This file is part of Beast: https://github.com/vinniefalco/Beast
-    Copyright 2013, Vinnie Falco <vinnie.falco@gmail.com>
-
-    Portions of this file are from JUCE.
-    Copyright (c) 2013 - Raw Material Software Ltd.
-    Please visit http://www.juce.com
-
-    Permission to use, copy, modify, and/or distribute this software for any
-    purpose  with  or without fee is hereby granted, provided that the above
-    copyright notice and this permission notice appear in all copies.
-
-    THE  SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
-    WITH  REGARD  TO  THIS  SOFTWARE  INCLUDING  ALL  IMPLIED  WARRANTIES  OF
-    MERCHANTABILITY  AND  FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
-    ANY  SPECIAL ,  DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
-    WHATSOEVER  RESULTING  FROM  LOSS  OF USE, DATA OR PROFITS, WHETHER IN AN
-    ACTION  OF  CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
-    OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
-*/
-//==============================================================================
-
-#ifndef BEAST_CSTDINT_H_INCLUDED
-#define BEAST_CSTDINT_H_INCLUDED
-
-#include "Config.h"
-
-namespace beast {
-
-typedef signed char                 int8;
-typedef signed short                int16;
-typedef signed int                  int32;
-typedef unsigned char               uint8;
-typedef unsigned short              uint16;
-typedef unsigned int                uint32;
-
-#if BEAST_MSVC
-  typedef __int64                   int64;
-  typedef unsigned __int64          uint64;
-
-  /** A platform-independent macro for writing 64-bit literals, needed because
-      different compilers have different syntaxes for this.
-
-      E.g. writing literal64bit (0x1000000000) will translate to 0x1000000000LL for
-      GCC, or 0x1000000000 for MSVC.
-  */
-  #define literal64bit(longLiteral)     ((__int64) longLiteral)
-
-#else
-  /** A platform-independent 64-bit integer type. */
-  typedef long long                 int64;
-  /** A platform-independent 64-bit unsigned integer type. */
-  typedef unsigned long long        uint64;
-  /** A platform-independent macro for writing 64-bit literals, needed because
-      different compilers have different syntaxes for this.
-
-      E.g. writing literal64bit (0x1000000000) will translate to 0x1000000000LL for
-      GCC, or 0x1000000000 for MSVC.
-  */
-  #define literal64bit(longLiteral)     (longLiteral##LL)
-
-#endif
-
-#if BEAST_64BIT
-  /** A signed integer type that's guaranteed to be large enough to hold a pointer without truncating it. */
-  typedef int64                     pointer_sized_int;
-  /** An unsigned integer type that's guaranteed to be large enough to hold a pointer without truncating it. */
-  typedef uint64                    pointer_sized_uint;
-#elif BEAST_MSVC
-  /** A signed integer type that's guaranteed to be large enough to hold a pointer without truncating it. */
-  typedef _W64 int                  pointer_sized_int;
-  /** An unsigned integer type that's guaranteed to be large enough to hold a pointer without truncating it. */
-  typedef _W64 unsigned int         pointer_sized_uint;
-#else
-  /** A signed integer type that's guaranteed to be large enough to hold a pointer without truncating it. */
-  typedef int                       pointer_sized_int;
-  /** An unsigned integer type that's guaranteed to be large enough to hold a pointer without truncating it. */
-  typedef unsigned int              pointer_sized_uint;
-#endif
-
-#if BEAST_MSVC
-  typedef pointer_sized_int ssize_t;
-#endif
-
-}
-
-#endif

src/beast/beast/Chrono.h

@@ -20,15 +20,13 @@
 #ifndef BEAST_CHRONO_H_INCLUDED
 #define BEAST_CHRONO_H_INCLUDED
 
-#include "chrono/abstract_clock.h"
-#include "chrono/basic_seconds_clock.h"
-#include "chrono/chrono_io.h"
-#include "chrono/chrono_util.h"
-#include "chrono/manual_clock.h"
-#include "chrono/ratio_io.h"
+#include <beast/chrono/abstract_clock.h>
+#include <beast/chrono/basic_seconds_clock.h>
+#include <beast/chrono/chrono_io.h>
+#include <beast/chrono/chrono_util.h>
+#include <beast/chrono/manual_clock.h>
+#include <beast/chrono/ratio_io.h>
 
-#include "chrono/CPUMeter.h"
-#include "chrono/RelativeTime.h"
-#include "chrono/ScopedTimeInterval.h"
+#include <beast/chrono/RelativeTime.h>
 
 #endif

src/beast/beast/Config.h

@@ -26,35 +26,38 @@
 
 // VFALCO NOTE this is analogous to <boost/config.hpp>
 
+// Assert to boost that we always have std::array support
+#define BOOST_ASIO_HAS_STD_ARRAY 1
+
 #if !defined(BEAST_COMPILER_CONFIG) && !defined(BEAST_NO_COMPILER_CONFIG) && !defined(BEAST_NO_CONFIG)
-#include "config/SelectCompilerConfig.h"
+#include <beast/config/SelectCompilerConfig.h>
 #endif
 #ifdef   BEAST_COMPILER_CONFIG
 #include BEAST_COMPILER_CONFIG
 #endif
 
 #if !defined(BEAST_STDLIB_CONFIG) && !defined(BEAST_NO_STDLIB_CONFIG) && !defined(BEAST_NO_CONFIG) && defined(__cplusplus)
-#include "config/SelectStdlibConfig.h"
+#include <beast/config/SelectStdlibConfig.h>
 #endif
 #ifdef   BEAST_STDLIB_CONFIG
 #include BEAST_STDLIB_CONFIG
 #endif
 
 #if !defined(BEAST_PLATFORM_CONFIG) && !defined(BEAST_NO_PLATFORM_CONFIG) && !defined(BEAST_NO_CONFIG)
-#include "config/SelectCompilerConfig.h"
+#include <beast/config/SelectCompilerConfig.h>
 #endif
 #ifdef   BEAST_PLATFORM_CONFIG
 #include BEAST_PLATFORM_CONFIG
 #endif
 
 // Legacy
-#include "Version.h"
-#include "config/PlatformConfig.h"
-#include "config/CompilerConfig.h"
-#include "config/StandardConfig.h"
-#include "config/ConfigCheck.h"
+#include <beast/Version.h>
+#include <beast/config/PlatformConfig.h>
+#include <beast/config/CompilerConfig.h>
+#include <beast/config/StandardConfig.h>
+#include <beast/config/ConfigCheck.h>
 
 // Suffix
-#include "config/Suffix.h"
+#include <beast/config/Suffix.h>
     
 #endif