No OneTemporary
Actions

Size

65 KB

Subscribers

None

View Options

	diff --git a/bitcoin-qt.pro b/bitcoin-qt.pro
	index 5274de426..6c1c4a78c 100644
	--- a/bitcoin-qt.pro
	+++ b/bitcoin-qt.pro
	@@ -1,402 +1,403 @@
	TEMPLATE = app
	TARGET = bitcoin-qt
	VERSION = 0.7.99
	INCLUDEPATH += src src/json src/qt
	DEFINES += QT_GUI BOOST_THREAD_USE_LIB BOOST_SPIRIT_THREADSAFE
	CONFIG += no_include_pwd
	CONFIG += thread

	# for boost 1.37, add -mt to the boost libraries
	# use: qmake BOOST_LIB_SUFFIX=-mt
	# for boost thread win32 with _win32 sufix
	# use: BOOST_THREAD_LIB_SUFFIX=_win32-...
	# or when linking against a specific BerkelyDB version: BDB_LIB_SUFFIX=-4.8

	# Dependency library locations can be customized with:
	# BOOST_INCLUDE_PATH, BOOST_LIB_PATH, BDB_INCLUDE_PATH,
	# BDB_LIB_PATH, OPENSSL_INCLUDE_PATH and OPENSSL_LIB_PATH respectively

	OBJECTS_DIR = build
	MOC_DIR = build
	UI_DIR = build

	# use: qmake "RELEASE=1"
	contains(RELEASE, 1) {
	# Mac: compile for maximum compatibility (10.5, 32-bit)
	macx:QMAKE_CXXFLAGS += -mmacosx-version-min=10.5 -arch i386 -isysroot /Developer/SDKs/MacOSX10.5.sdk
	macx:QMAKE_CFLAGS += -mmacosx-version-min=10.5 -arch i386 -isysroot /Developer/SDKs/MacOSX10.5.sdk
	macx:QMAKE_OBJECTIVE_CFLAGS += -mmacosx-version-min=10.5 -arch i386 -isysroot /Developer/SDKs/MacOSX10.5.sdk

	!win32:!macx {
	# Linux: static link
	LIBS += -Wl,-Bstatic
	}
	}

	!win32 {
	# for extra security against potential buffer overflows: enable GCCs Stack Smashing Protection
	QMAKE_CXXFLAGS *= -fstack-protector-all
	QMAKE_LFLAGS *= -fstack-protector-all
	# We need to exclude this for Windows cross compile with MinGW 4.2.x, as it will result in a non-working executable!
	# This can be enabled for Windows, when we switch to MinGW >= 4.4.x.
	}
	# for extra security (see: https://wiki.debian.org/Hardening)
	QMAKE_CXXFLAGS *= -D_FORTIFY_SOURCE=2 -Wl,-z,relro -Wl,-z,now
	# for extra security on Windows: enable ASLR and DEP via GCC linker flags
	win32:QMAKE_LFLAGS *= -Wl,--dynamicbase -Wl,--nxcompat
	# on Windows: enable GCC large address aware linker flag
	win32:QMAKE_LFLAGS *= -Wl,--large-address-aware

	# use: qmake "USE_QRCODE=1"
	# libqrencode (http://fukuchi.org/works/qrencode/index.en.html) must be installed for support
	contains(USE_QRCODE, 1) {
	message(Building with QRCode support)
	DEFINES += USE_QRCODE
	LIBS += -lqrencode
	}

	# use: qmake "USE_UPNP=1" ( enabled by default; default)
	# or: qmake "USE_UPNP=0" (disabled by default)
	# or: qmake "USE_UPNP=-" (not supported)
	# miniupnpc (http://miniupnp.free.fr/files/) must be installed for support
	contains(USE_UPNP, -) {
	message(Building without UPNP support)
	} else {
	message(Building with UPNP support)
	count(USE_UPNP, 0) {
	USE_UPNP=1
	}
	DEFINES += USE_UPNP=$$USE_UPNP STATICLIB
	INCLUDEPATH += $$MINIUPNPC_INCLUDE_PATH
	LIBS += $$join(MINIUPNPC_LIB_PATH,,-L,) -lminiupnpc
	win32:LIBS += -liphlpapi
	}

	# use: qmake "USE_DBUS=1"
	contains(USE_DBUS, 1) {
	message(Building with DBUS (Freedesktop notifications) support)
	DEFINES += USE_DBUS
	QT += dbus
	}

	# use: qmake "USE_IPV6=1" ( enabled by default; default)
	# or: qmake "USE_IPV6=0" (disabled by default)
	# or: qmake "USE_IPV6=-" (not supported)
	contains(USE_IPV6, -) {
	message(Building without IPv6 support)
	} else {
	count(USE_IPV6, 0) {
	USE_IPV6=1
	}
	DEFINES += USE_IPV6=$$USE_IPV6
	}

	contains(BITCOIN_NEED_QT_PLUGINS, 1) {
	DEFINES += BITCOIN_NEED_QT_PLUGINS
	QTPLUGIN += qcncodecs qjpcodecs qtwcodecs qkrcodecs qtaccessiblewidgets
	}

	INCLUDEPATH += src/leveldb/include src/leveldb/helpers
	LIBS += $$PWD/src/leveldb/libleveldb.a $$PWD/src/leveldb/libmemenv.a
	!win32 {
	genleveldb.commands = cd $$PWD/src/leveldb && $(MAKE) libleveldb.a libmemenv.a
	} else {
	# make an educated guess about what the ranlib command is called
	isEmpty(QMAKE_RANLIB) {
	QMAKE_RANLIB = $$replace(QMAKE_STRIP, strip, ranlib)
	}
	- genleveldb.commands = cd $$PWD/src/leveldb && CC=$$QMAKE_CC CXX=$$QMAKE_CXX TARGET_OS=OS_WINDOWS_CROSSCOMPILE CXXFLAGS="-I$$BOOST_INCLUDE_PATH" LDFLAGS="-L$$BOOST_LIB_PATH" $(MAKE) libleveldb.a libmemenv.a && $$QMAKE_RANLIB $$PWD/src/leveldb/libleveldb.a && $$QMAKE_RANLIB $$PWD/src/leveldb/libmemenv.a
	+ LIBS += -lshlwapi
	+ genleveldb.commands = cd $$PWD/src/leveldb && CC=$$QMAKE_CC CXX=$$QMAKE_CXX TARGET_OS=OS_WINDOWS_CROSSCOMPILE $(MAKE) libleveldb.a libmemenv.a && $$QMAKE_RANLIB $$PWD/src/leveldb/libleveldb.a && $$QMAKE_RANLIB $$PWD/src/leveldb/libmemenv.a
	}
	genleveldb.target = $$PWD/src/leveldb/libleveldb.a
	genleveldb.depends = FORCE
	PRE_TARGETDEPS += $$PWD/src/leveldb/libleveldb.a
	QMAKE_EXTRA_TARGETS += genleveldb
	-# Gross ugly hack that depends on qmake internals, unfortunately there's no other way to do it.
	+# Gross ugly hack that depends on qmake internals, unfortunately there is no other way to do it.
	QMAKE_CLEAN += $$PWD/src/leveldb/libleveldb.a; cd $$PWD/src/leveldb ; $(MAKE) clean

	# regenerate src/build.h
	!win32\|contains(USE_BUILD_INFO, 1) {
	genbuild.depends = FORCE
	genbuild.commands = cd $$PWD; /bin/sh share/genbuild.sh $$OUT_PWD/build/build.h
	genbuild.target = $$OUT_PWD/build/build.h
	PRE_TARGETDEPS += $$OUT_PWD/build/build.h
	QMAKE_EXTRA_TARGETS += genbuild
	DEFINES += HAVE_BUILD_INFO
	}

	QMAKE_CXXFLAGS_WARN_ON = -fdiagnostics-show-option -Wall -Wextra -Wformat -Wformat-security -Wno-unused-parameter -Wstack-protector

	# Input
	DEPENDPATH += src src/json src/qt
	HEADERS += src/qt/bitcoingui.h \
	src/qt/transactiontablemodel.h \
	src/qt/addresstablemodel.h \
	src/qt/optionsdialog.h \
	src/qt/sendcoinsdialog.h \
	src/qt/addressbookpage.h \
	src/qt/signverifymessagedialog.h \
	src/qt/aboutdialog.h \
	src/qt/editaddressdialog.h \
	src/qt/bitcoinaddressvalidator.h \
	src/alert.h \
	src/addrman.h \
	src/base58.h \
	src/bignum.h \
	src/checkpoints.h \
	src/compat.h \
	src/sync.h \
	src/util.h \
	src/hash.h \
	src/uint256.h \
	src/serialize.h \
	src/main.h \
	src/net.h \
	src/key.h \
	src/db.h \
	src/walletdb.h \
	src/script.h \
	src/init.h \
	src/irc.h \
	src/bloom.h \
	src/mruset.h \
	src/checkqueue.h \
	src/json/json_spirit_writer_template.h \
	src/json/json_spirit_writer.h \
	src/json/json_spirit_value.h \
	src/json/json_spirit_utils.h \
	src/json/json_spirit_stream_reader.h \
	src/json/json_spirit_reader_template.h \
	src/json/json_spirit_reader.h \
	src/json/json_spirit_error_position.h \
	src/json/json_spirit.h \
	src/qt/clientmodel.h \
	src/qt/guiutil.h \
	src/qt/transactionrecord.h \
	src/qt/guiconstants.h \
	src/qt/optionsmodel.h \
	src/qt/monitoreddatamapper.h \
	src/qt/transactiondesc.h \
	src/qt/transactiondescdialog.h \
	src/qt/bitcoinamountfield.h \
	src/wallet.h \
	src/keystore.h \
	src/qt/transactionfilterproxy.h \
	src/qt/transactionview.h \
	src/qt/walletmodel.h \
	src/bitcoinrpc.h \
	src/qt/overviewpage.h \
	src/qt/csvmodelwriter.h \
	src/crypter.h \
	src/qt/sendcoinsentry.h \
	src/qt/qvalidatedlineedit.h \
	src/qt/bitcoinunits.h \
	src/qt/qvaluecombobox.h \
	src/qt/askpassphrasedialog.h \
	src/protocol.h \
	src/qt/notificator.h \
	src/qt/qtipcserver.h \
	src/allocators.h \
	src/ui_interface.h \
	src/qt/rpcconsole.h \
	src/version.h \
	src/netbase.h \
	src/clientversion.h \
	src/txdb.h \
	src/leveldb.h \
	src/threadsafety.h

	SOURCES += src/qt/bitcoin.cpp src/qt/bitcoingui.cpp \
	src/qt/transactiontablemodel.cpp \
	src/qt/addresstablemodel.cpp \
	src/qt/optionsdialog.cpp \
	src/qt/sendcoinsdialog.cpp \
	src/qt/addressbookpage.cpp \
	src/qt/signverifymessagedialog.cpp \
	src/qt/aboutdialog.cpp \
	src/qt/editaddressdialog.cpp \
	src/qt/bitcoinaddressvalidator.cpp \
	src/alert.cpp \
	src/version.cpp \
	src/sync.cpp \
	src/util.cpp \
	src/hash.cpp \
	src/netbase.cpp \
	src/key.cpp \
	src/script.cpp \
	src/main.cpp \
	src/init.cpp \
	src/net.cpp \
	src/irc.cpp \
	src/bloom.cpp \
	src/checkpoints.cpp \
	src/addrman.cpp \
	src/db.cpp \
	src/walletdb.cpp \
	src/qt/clientmodel.cpp \
	src/qt/guiutil.cpp \
	src/qt/transactionrecord.cpp \
	src/qt/optionsmodel.cpp \
	src/qt/monitoreddatamapper.cpp \
	src/qt/transactiondesc.cpp \
	src/qt/transactiondescdialog.cpp \
	src/qt/bitcoinstrings.cpp \
	src/qt/bitcoinamountfield.cpp \
	src/wallet.cpp \
	src/keystore.cpp \
	src/qt/transactionfilterproxy.cpp \
	src/qt/transactionview.cpp \
	src/qt/walletmodel.cpp \
	src/bitcoinrpc.cpp \
	src/rpcdump.cpp \
	src/rpcnet.cpp \
	src/rpcmining.cpp \
	src/rpcwallet.cpp \
	src/rpcblockchain.cpp \
	src/rpcrawtransaction.cpp \
	src/qt/overviewpage.cpp \
	src/qt/csvmodelwriter.cpp \
	src/crypter.cpp \
	src/qt/sendcoinsentry.cpp \
	src/qt/qvalidatedlineedit.cpp \
	src/qt/bitcoinunits.cpp \
	src/qt/qvaluecombobox.cpp \
	src/qt/askpassphrasedialog.cpp \
	src/protocol.cpp \
	src/qt/notificator.cpp \
	src/qt/qtipcserver.cpp \
	src/qt/rpcconsole.cpp \
	src/noui.cpp \
	src/leveldb.cpp \
	src/txdb.cpp

	RESOURCES += \
	src/qt/bitcoin.qrc

	FORMS += \
	src/qt/forms/sendcoinsdialog.ui \
	src/qt/forms/addressbookpage.ui \
	src/qt/forms/signverifymessagedialog.ui \
	src/qt/forms/aboutdialog.ui \
	src/qt/forms/editaddressdialog.ui \
	src/qt/forms/transactiondescdialog.ui \
	src/qt/forms/overviewpage.ui \
	src/qt/forms/sendcoinsentry.ui \
	src/qt/forms/askpassphrasedialog.ui \
	src/qt/forms/rpcconsole.ui \
	src/qt/forms/optionsdialog.ui

	contains(USE_QRCODE, 1) {
	HEADERS += src/qt/qrcodedialog.h
	SOURCES += src/qt/qrcodedialog.cpp
	FORMS += src/qt/forms/qrcodedialog.ui
	}

	contains(BITCOIN_QT_TEST, 1) {
	SOURCES += src/qt/test/test_main.cpp \
	src/qt/test/uritests.cpp
	HEADERS += src/qt/test/uritests.h
	DEPENDPATH += src/qt/test
	QT += testlib
	TARGET = bitcoin-qt_test
	DEFINES += BITCOIN_QT_TEST
	}

	CODECFORTR = UTF-8

	# for lrelease/lupdate
	# also add new translations to src/qt/bitcoin.qrc under translations/
	TRANSLATIONS = $$files(src/qt/locale/bitcoin_*.ts)

	isEmpty(QMAKE_LRELEASE) {
	win32:QMAKE_LRELEASE = $$[QT_INSTALL_BINS]\\lrelease.exe
	else:QMAKE_LRELEASE = $$[QT_INSTALL_BINS]/lrelease
	}
	isEmpty(QM_DIR):QM_DIR = $$PWD/src/qt/locale
	# automatically build translations, so they can be included in resource file
	TSQM.name = lrelease ${QMAKE_FILE_IN}
	TSQM.input = TRANSLATIONS
	TSQM.output = $$QM_DIR/${QMAKE_FILE_BASE}.qm
	TSQM.commands = $$QMAKE_LRELEASE ${QMAKE_FILE_IN} -qm ${QMAKE_FILE_OUT}
	TSQM.CONFIG = no_link
	QMAKE_EXTRA_COMPILERS += TSQM

	# "Other files" to show in Qt Creator
	OTHER_FILES += \
	doc/.rst doc/.txt doc/README README.md res/bitcoin-qt.rc src/test/.cpp src/test/.h src/qt/test/.cpp src/qt/test/.h

	# platform specific defaults, if not overridden on command line
	isEmpty(BOOST_LIB_SUFFIX) {
	macx:BOOST_LIB_SUFFIX = -mt
	win32:BOOST_LIB_SUFFIX = -mgw44-mt-s-1_50
	}

	isEmpty(BOOST_THREAD_LIB_SUFFIX) {
	BOOST_THREAD_LIB_SUFFIX = $$BOOST_LIB_SUFFIX
	}

	isEmpty(BDB_LIB_PATH) {
	macx:BDB_LIB_PATH = /opt/local/lib/db48
	}

	isEmpty(BDB_LIB_SUFFIX) {
	macx:BDB_LIB_SUFFIX = -4.8
	}

	isEmpty(BDB_INCLUDE_PATH) {
	macx:BDB_INCLUDE_PATH = /opt/local/include/db48
	}

	isEmpty(BOOST_LIB_PATH) {
	macx:BOOST_LIB_PATH = /opt/local/lib
	}

	isEmpty(BOOST_INCLUDE_PATH) {
	macx:BOOST_INCLUDE_PATH = /opt/local/include
	}

	win32:DEFINES += WIN32
	win32:RC_FILE = src/qt/res/bitcoin-qt.rc

	win32:!contains(MINGW_THREAD_BUGFIX, 0) {
	# At least qmake's win32-g++-cross profile is missing the -lmingwthrd
	# thread-safety flag. GCC has -mthreads to enable this, but it doesn't
	# work with static linking. -lmingwthrd must come BEFORE -lmingw, so
	# it is prepended to QMAKE_LIBS_QT_ENTRY.
	# It can be turned off with MINGW_THREAD_BUGFIX=0, just in case it causes
	# any problems on some untested qmake profile now or in the future.
	DEFINES += _MT
	QMAKE_LIBS_QT_ENTRY = -lmingwthrd $$QMAKE_LIBS_QT_ENTRY
	}

	!win32:!macx {
	DEFINES += LINUX
	LIBS += -lrt
	}

	macx:HEADERS += src/qt/macdockiconhandler.h
	macx:OBJECTIVE_SOURCES += src/qt/macdockiconhandler.mm
	macx:LIBS += -framework Foundation -framework ApplicationServices -framework AppKit
	macx:DEFINES += MAC_OSX MSG_NOSIGNAL=0
	macx:ICON = src/qt/res/icons/bitcoin.icns
	macx:TARGET = "Bitcoin-Qt"
	macx:QMAKE_CFLAGS_THREAD += -pthread
	macx:QMAKE_LFLAGS_THREAD += -pthread
	macx:QMAKE_CXXFLAGS_THREAD += -pthread

	# Set libraries and includes at end, to use platform-defined defaults if not overridden
	INCLUDEPATH += $$BOOST_INCLUDE_PATH $$BDB_INCLUDE_PATH $$OPENSSL_INCLUDE_PATH $$QRENCODE_INCLUDE_PATH
	LIBS += $$join(BOOST_LIB_PATH,,-L,) $$join(BDB_LIB_PATH,,-L,) $$join(OPENSSL_LIB_PATH,,-L,) $$join(QRENCODE_LIB_PATH,,-L,)
	LIBS += -lssl -lcrypto -ldb_cxx$$BDB_LIB_SUFFIX
	# -lgdi32 has to happen after -lcrypto (see #681)
	win32:LIBS += -lws2_32 -lshlwapi -lmswsock -lole32 -loleaut32 -luuid -lgdi32
	LIBS += -lboost_system$$BOOST_LIB_SUFFIX -lboost_filesystem$$BOOST_LIB_SUFFIX -lboost_program_options$$BOOST_LIB_SUFFIX -lboost_thread$$BOOST_THREAD_LIB_SUFFIX
	win32:LIBS += -lboost_chrono$$BOOST_LIB_SUFFIX

	contains(RELEASE, 1) {
	!win32:!macx {
	# Linux: turn dynamic linking back on for c/c++ runtime libraries
	LIBS += -Wl,-Bdynamic
	}
	}

	system($$QMAKE_LRELEASE -silent $$_PRO_FILE_)
	diff --git a/src/leveldb/build_detect_platform b/src/leveldb/build_detect_platform
	index caf2352f9..1080df77f 100755
	--- a/src/leveldb/build_detect_platform
	+++ b/src/leveldb/build_detect_platform
	@@ -1,201 +1,199 @@
	#!/bin/sh
	#
	# Detects OS we're compiling on and outputs a file specified by the first
	# argument, which in turn gets read while processing Makefile.
	#
	# The output will set the following variables:
	# CC C Compiler path
	# CXX C++ Compiler path
	# PLATFORM_LDFLAGS Linker flags
	# PLATFORM_LIBS Libraries flags
	# PLATFORM_SHARED_EXT Extension for shared libraries
	# PLATFORM_SHARED_LDFLAGS Flags for building shared library
	# This flag is embedded just before the name
	# of the shared library without intervening spaces
	# PLATFORM_SHARED_CFLAGS Flags for compiling objects for shared library
	# PLATFORM_CCFLAGS C compiler flags
	# PLATFORM_CXXFLAGS C++ compiler flags. Will contain:
	# PLATFORM_SHARED_VERSIONED Set to 'true' if platform supports versioned
	# shared libraries, empty otherwise.
	#
	# The PLATFORM_CCFLAGS and PLATFORM_CXXFLAGS might include the following:
	#
	# -DLEVELDB_CSTDATOMIC_PRESENT if <cstdatomic> is present
	# -DLEVELDB_PLATFORM_POSIX for Posix-based platforms
	# -DSNAPPY if the Snappy library is present
	#

	OUTPUT=$1
	PREFIX=$2
	if test -z "$OUTPUT" \|\| test -z "$PREFIX"; then
	echo "usage: $0 <output-filename> <directory_prefix>" >&2
	exit 1
	fi

	# Delete existing output, if it exists
	rm -f $OUTPUT
	touch $OUTPUT

	if test -z "$CC"; then
	CC=cc
	fi

	if test -z "$CXX"; then
	CXX=g++
	fi

	# Detect OS
	if test -z "$TARGET_OS"; then
	TARGET_OS=`uname -s`
	fi

	COMMON_FLAGS=
	CROSS_COMPILE=
	PLATFORM_CCFLAGS=
	PLATFORM_CXXFLAGS=
	PLATFORM_LDFLAGS=
	PLATFORM_LIBS=
	PLATFORM_SHARED_EXT="so"
	PLATFORM_SHARED_LDFLAGS="-shared -Wl,-soname -Wl,"
	PLATFORM_SHARED_CFLAGS="-fPIC"
	PLATFORM_SHARED_VERSIONED=true

	MEMCMP_FLAG=
	if [ "$CXX" = "g++" ]; then
	# Use libc's memcmp instead of GCC's memcmp. This results in ~40%
	# performance improvement on readrandom under gcc 4.4.3 on Linux/x86.
	MEMCMP_FLAG="-fno-builtin-memcmp"
	fi

	case "$TARGET_OS" in
	Darwin)
	PLATFORM=OS_MACOSX
	COMMON_FLAGS="$MEMCMP_FLAG -DOS_MACOSX"
	PLATFORM_SHARED_EXT=dylib
	[ -z "$INSTALL_PATH" ] && INSTALL_PATH=`pwd`
	PLATFORM_SHARED_LDFLAGS="-dynamiclib -install_name $INSTALL_PATH/"
	PORT_FILE=port/port_posix.cc
	;;
	Linux)
	PLATFORM=OS_LINUX
	COMMON_FLAGS="$MEMCMP_FLAG -pthread -DOS_LINUX"
	PLATFORM_LDFLAGS="-pthread"
	PORT_FILE=port/port_posix.cc
	;;
	SunOS)
	PLATFORM=OS_SOLARIS
	COMMON_FLAGS="$MEMCMP_FLAG -D_REENTRANT -DOS_SOLARIS"
	PLATFORM_LIBS="-lpthread -lrt"
	PORT_FILE=port/port_posix.cc
	;;
	FreeBSD)
	PLATFORM=OS_FREEBSD
	COMMON_FLAGS="$MEMCMP_FLAG -D_REENTRANT -DOS_FREEBSD"
	PLATFORM_LIBS="-lpthread"
	PORT_FILE=port/port_posix.cc
	;;
	NetBSD)
	PLATFORM=OS_NETBSD
	COMMON_FLAGS="$MEMCMP_FLAG -D_REENTRANT -DOS_NETBSD"
	PLATFORM_LIBS="-lpthread -lgcc_s"
	PORT_FILE=port/port_posix.cc
	;;
	OpenBSD)
	PLATFORM=OS_OPENBSD
	COMMON_FLAGS="$MEMCMP_FLAG -D_REENTRANT -DOS_OPENBSD"
	PLATFORM_LDFLAGS="-pthread"
	PORT_FILE=port/port_posix.cc
	;;
	DragonFly)
	PLATFORM=OS_DRAGONFLYBSD
	COMMON_FLAGS="$MEMCMP_FLAG -D_REENTRANT -DOS_DRAGONFLYBSD"
	PLATFORM_LIBS="-lpthread"
	PORT_FILE=port/port_posix.cc
	;;
	OS_ANDROID_CROSSCOMPILE)
	PLATFORM=OS_ANDROID
	COMMON_FLAGS="$MEMCMP_FLAG -D_REENTRANT -DOS_ANDROID -DLEVELDB_PLATFORM_POSIX"
	PLATFORM_LDFLAGS="" # All pthread features are in the Android C library
	PORT_FILE=port/port_posix.cc
	CROSS_COMPILE=true
	;;
	HP-UX)
	PLATFORM=OS_HPUX
	COMMON_FLAGS="$MEMCMP_FLAG -D_REENTRANT -DOS_HPUX"
	PLATFORM_LDFLAGS="-pthread"
	PORT_FILE=port/port_posix.cc
	# man ld: +h internal_name
	PLATFORM_SHARED_LDFLAGS="-shared -Wl,+h -Wl,"
	;;
	OS_WINDOWS_CROSSCOMPILE \| NATIVE_WINDOWS)
	PLATFORM=OS_WINDOWS
	- COMMON_FLAGS="-fno-builtin-memcmp -D_REENTRANT -DOS_WINDOWS -DLEVELDB_PLATFORM_WINDOWS"
	- PLATFORM_SHARED_CFLAGS=""
	+ COMMON_FLAGS="-fno-builtin-memcmp -D_REENTRANT -DOS_WINDOWS -DLEVELDB_PLATFORM_WINDOWS -DWINVER=0x0500 -D__USE_MINGW_ANSI_STDIO=1"
	PLATFORM_SOURCES="util/env_win.cc"
	- PLATFORM_CXXFLAGS="-std=c++0x"
	- PLATFORM_LIBS="-lshlwapi -ldbghelp"
	+ PLATFORM_LIBS="-lshlwapi"
	PORT_FILE=port/port_win.cc
	CROSS_COMPILE=true
	;;
	*)
	echo "Unknown platform!" >&2
	exit 1
	esac

	# We want to make a list of all cc files within util, db, table, and helpers
	# except for the test and benchmark files. By default, find will output a list
	# of all files matching either rule, so we need to append -print to make the
	# prune take effect.
	DIRS="$PREFIX/db $PREFIX/util $PREFIX/table"

	set -f # temporarily disable globbing so that our patterns aren't expanded
	PRUNE_TEST="-name test.cc -prune"
	PRUNE_BENCH="-name *_bench.cc -prune"
	PORTABLE_FILES=`find $DIRS $PRUNE_TEST -o $PRUNE_BENCH -o -name '*.cc' -print \| sort \| sed "s,^$PREFIX/,," \| tr "\n" " "`

	set +f # re-enable globbing

	# The sources consist of the portable files, plus the platform-specific port
	# file.
	echo "SOURCES=$PORTABLE_FILES $PORT_FILE" >> $OUTPUT
	echo "MEMENV_SOURCES=helpers/memenv/memenv.cc" >> $OUTPUT

	if [ "$CROSS_COMPILE" = "true" ]; then
	# Cross-compiling; do not try any compilation tests.
	true
	else
	# If -std=c++0x works, use <cstdatomic>. Otherwise use port_posix.h.
	$CXX $CXXFLAGS -std=c++0x -x c++ - -o /dev/null 2>/dev/null <<EOF
	#include <cstdatomic>
	int main() {}
	EOF
	if [ "$?" = 0 ]; then
	COMMON_FLAGS="$COMMON_FLAGS -DLEVELDB_PLATFORM_POSIX -DLEVELDB_CSTDATOMIC_PRESENT"
	PLATFORM_CXXFLAGS="-std=c++0x"
	else
	COMMON_FLAGS="$COMMON_FLAGS -DLEVELDB_PLATFORM_POSIX"
	fi

	# Test whether tcmalloc is available
	$CXX $CXXFLAGS -x c++ - -o /dev/null -ltcmalloc 2>/dev/null <<EOF
	int main() {}
	EOF
	if [ "$?" = 0 ]; then
	PLATFORM_LIBS="$PLATFORM_LIBS -ltcmalloc"
	fi
	fi

	PLATFORM_CCFLAGS="$PLATFORM_CCFLAGS $COMMON_FLAGS"
	PLATFORM_CXXFLAGS="$PLATFORM_CXXFLAGS $COMMON_FLAGS"

	echo "CC=$CC" >> $OUTPUT
	echo "CXX=$CXX" >> $OUTPUT
	echo "PLATFORM=$PLATFORM" >> $OUTPUT
	echo "PLATFORM_LDFLAGS=$PLATFORM_LDFLAGS" >> $OUTPUT
	echo "PLATFORM_LIBS=$PLATFORM_LIBS" >> $OUTPUT
	echo "PLATFORM_CCFLAGS=$PLATFORM_CCFLAGS" >> $OUTPUT
	echo "PLATFORM_CXXFLAGS=$PLATFORM_CXXFLAGS" >> $OUTPUT
	echo "PLATFORM_SHARED_CFLAGS=$PLATFORM_SHARED_CFLAGS" >> $OUTPUT
	echo "PLATFORM_SHARED_EXT=$PLATFORM_SHARED_EXT" >> $OUTPUT
	echo "PLATFORM_SHARED_LDFLAGS=$PLATFORM_SHARED_LDFLAGS" >> $OUTPUT
	echo "PLATFORM_SHARED_VERSIONED=$PLATFORM_SHARED_VERSIONED" >> $OUTPUT
	diff --git a/src/leveldb/port/port_win.cc b/src/leveldb/port/port_win.cc
	index 15dfde1f2..99c1d8e34 100644
	--- a/src/leveldb/port/port_win.cc
	+++ b/src/leveldb/port/port_win.cc
	@@ -1,149 +1,149 @@
	// LevelDB Copyright (c) 2011 The LevelDB Authors. All rights reserved.
	// Use of this source code is governed by a BSD-style license that can be
	// found in the LICENSE file. See the AUTHORS file for names of contributors.
	//
	// See port_example.h for documentation for the following types/functions.

	// 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 binary form must reproduce the above copyright
	// notice, this list of conditions and the following disclaimer in the
	// documentation and/or other materials provided with the distribution.
	// * Neither the name of the University of California, Berkeley nor the
	// names of its contributors may be used to endorse or promote products
	// derived from this software without specific prior written permission.
	//
	// THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND ANY
	// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
	// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
	// DISCLAIMED. IN NO EVENT SHALL THE REGENTS AND 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.
	//

	#include "port/port_win.h"

	#include <windows.h>
	#include <cassert>

	namespace leveldb {
	namespace port {

	Mutex::Mutex() :
	- cs_(nullptr) {
	+ cs_(NULL) {
	assert(!cs_);
	cs_ = static_cast<void *>(new CRITICAL_SECTION());
	::InitializeCriticalSection(static_cast<CRITICAL_SECTION *>(cs_));
	assert(cs_);
	}

	Mutex::~Mutex() {
	assert(cs_);
	::DeleteCriticalSection(static_cast<CRITICAL_SECTION *>(cs_));
	delete static_cast<CRITICAL_SECTION *>(cs_);
	- cs_ = nullptr;
	+ cs_ = NULL;
	assert(!cs_);
	}

	void Mutex::Lock() {
	assert(cs_);
	::EnterCriticalSection(static_cast<CRITICAL_SECTION *>(cs_));
	}

	void Mutex::Unlock() {
	assert(cs_);
	::LeaveCriticalSection(static_cast<CRITICAL_SECTION *>(cs_));
	}

	void Mutex::AssertHeld() {
	assert(cs_);
	assert(1);
	}

	CondVar::CondVar(Mutex* mu) :
	waiting_(0),
	mu_(mu),
	sem1_(::CreateSemaphore(NULL, 0, 10000, NULL)),
	sem2_(::CreateSemaphore(NULL, 0, 10000, NULL)) {
	assert(mu_);
	}

	CondVar::~CondVar() {
	::CloseHandle(sem1_);
	::CloseHandle(sem2_);
	}

	void CondVar::Wait() {
	mu_->AssertHeld();

	wait_mtx_.Lock();
	++waiting_;
	wait_mtx_.Unlock();

	mu_->Unlock();

	// initiate handshake
	::WaitForSingleObject(sem1_, INFINITE);
	::ReleaseSemaphore(sem2_, 1, NULL);
	mu_->Lock();
	}

	void CondVar::Signal() {
	wait_mtx_.Lock();
	if (waiting_ > 0) {
	--waiting_;

	// finalize handshake
	::ReleaseSemaphore(sem1_, 1, NULL);
	::WaitForSingleObject(sem2_, INFINITE);
	}
	wait_mtx_.Unlock();
	}

	void CondVar::SignalAll() {
	wait_mtx_.Lock();
	for(long i = 0; i < waiting_; ++i) {
	::ReleaseSemaphore(sem1_, 1, NULL);
	while(waiting_ > 0) {
	--waiting_;
	::WaitForSingleObject(sem2_, INFINITE);
	}
	}
	wait_mtx_.Unlock();
	}

	AtomicPointer::AtomicPointer(void* v) {
	Release_Store(v);
	}

	void InitOnce(OnceType* once, void (*initializer)()) {
	once->InitOnce(initializer);
	}

	void* AtomicPointer::Acquire_Load() const {
	- void * p = nullptr;
	+ void * p = NULL;
	InterlockedExchangePointer(&p, rep_);
	return p;
	}

	void AtomicPointer::Release_Store(void* v) {
	InterlockedExchangePointer(&rep_, v);
	}

	void* AtomicPointer::NoBarrier_Load() const {
	return rep_;
	}

	void AtomicPointer::NoBarrier_Store(void* v) {
	rep_ = v;
	}

	}
	}
	diff --git a/src/leveldb/port/port_win.h b/src/leveldb/port/port_win.h
	index 849b01705..45bf2f0ea 100644
	--- a/src/leveldb/port/port_win.h
	+++ b/src/leveldb/port/port_win.h
	@@ -1,172 +1,174 @@
	// LevelDB Copyright (c) 2011 The LevelDB Authors. All rights reserved.
	// Use of this source code is governed by a BSD-style license that can be
	// found in the LICENSE file. See the AUTHORS file for names of contributors.
	//
	// See port_example.h for documentation for the following types/functions.

	// 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 binary form must reproduce the above copyright
	// notice, this list of conditions and the following disclaimer in the
	// documentation and/or other materials provided with the distribution.
	// * Neither the name of the University of California, Berkeley nor the
	// names of its contributors may be used to endorse or promote products
	// derived from this software without specific prior written permission.
	//
	// THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND ANY
	// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
	// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
	// DISCLAIMED. IN NO EVENT SHALL THE REGENTS AND 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.
	//

	#ifndef STORAGE_LEVELDB_PORT_PORT_WIN_H_
	#define STORAGE_LEVELDB_PORT_PORT_WIN_H_

	+#ifdef _MSC_VER
	#define snprintf _snprintf
	#define close _close
	#define fread_unlocked _fread_nolock
	+#endif

	#include <string>
	#include <stdint.h>
	#ifdef SNAPPY
	#include <snappy.h>
	#endif

	namespace leveldb {
	namespace port {

	// Windows is little endian (for now :p)
	static const bool kLittleEndian = true;

	class CondVar;

	class Mutex {
	public:
	Mutex();
	~Mutex();

	void Lock();
	void Unlock();
	void AssertHeld();

	private:
	friend class CondVar;
	// critical sections are more efficient than mutexes
	// but they are not recursive and can only be used to synchronize threads within the same process
	// we use opaque void * to avoid including windows.h in port_win.h
	void * cs_;

	// No copying
	Mutex(const Mutex&);
	void operator=(const Mutex&);
	};

	// the Win32 API offers a dependable condition variable mechanism, but only starting with
	// Windows 2008 and Vista
	// no matter what we will implement our own condition variable with a semaphore
	// implementation as described in a paper written by Andrew D. Birrell in 2003
	class CondVar {
	public:
	explicit CondVar(Mutex* mu);
	~CondVar();
	void Wait();
	void Signal();
	void SignalAll();
	private:
	Mutex* mu_;

	Mutex wait_mtx_;
	long waiting_;

	void * sem1_;
	void * sem2_;


	};

	class OnceType {
	public:
	// OnceType() : init_(false) {}
	OnceType(const OnceType &once) : init_(once.init_) {}
	OnceType(bool f) : init_(f) {}
	void InitOnce(void (*initializer)()) {
	mutex_.Lock();
	if (!init_) {
	init_ = true;
	initializer();
	}
	mutex_.Unlock();
	}

	private:
	bool init_;
	Mutex mutex_;
	};

	#define LEVELDB_ONCE_INIT false
	extern void InitOnce(port::OnceType, void (initializer)());

	// Storage for a lock-free pointer
	class AtomicPointer {
	private:
	void * rep_;
	public:
	- AtomicPointer() : rep_(nullptr) { }
	+ AtomicPointer() : rep_(NULL) { }
	explicit AtomicPointer(void* v);
	void* Acquire_Load() const;

	void Release_Store(void* v);

	void* NoBarrier_Load() const;

	void NoBarrier_Store(void* v);
	};

	inline bool Snappy_Compress(const char* input, size_t length,
	::std::string* output) {
	#ifdef SNAPPY
	output->resize(snappy::MaxCompressedLength(length));
	size_t outlen;
	snappy::RawCompress(input, length, &(*output)[0], &outlen);
	output->resize(outlen);
	return true;
	#endif

	return false;
	}

	inline bool Snappy_GetUncompressedLength(const char* input, size_t length,
	size_t* result) {
	#ifdef SNAPPY
	return snappy::GetUncompressedLength(input, length, result);
	#else
	return false;
	#endif
	}

	inline bool Snappy_Uncompress(const char* input, size_t length,
	char* output) {
	#ifdef SNAPPY
	return snappy::RawUncompress(input, length, output);
	#else
	return false;
	#endif
	}

	inline bool GetHeapProfile(void (func)(void, const char, int), void arg) {
	return false;
	}

	}
	}

	#endif // STORAGE_LEVELDB_PORT_PORT_WIN_H_
	diff --git a/src/leveldb/util/env_win.cc b/src/leveldb/util/env_win.cc
	index 384331aec..f1a761062 100644
	--- a/src/leveldb/util/env_win.cc
	+++ b/src/leveldb/util/env_win.cc
	@@ -1,1017 +1,1031 @@
	// This file contains source that originates from:
	// http://code.google.com/p/leveldbwin/source/browse/trunk/win32_impl_src/env_win32.h
	// http://code.google.com/p/leveldbwin/source/browse/trunk/win32_impl_src/port_win32.cc
	// Those files dont' have any explict license headers but the
	// project (http://code.google.com/p/leveldbwin/) lists the 'New BSD License'
	// as the license.
	#if defined(LEVELDB_PLATFORM_WINDOWS)
	#include <map>


	#include "leveldb/env.h"

	#include "port/port.h"
	#include "leveldb/slice.h"
	#include "util/logging.h"

	#include <shlwapi.h>
	#include <process.h>
	#include <cstring>
	#include <stdio.h>
	#include <errno.h>
	#include <io.h>
	-#include <dbghelp.h>
	#include <algorithm>
	-#pragma comment(lib,"DbgHelp.lib")

	#ifdef max
	#undef max
	#endif

	#ifndef va_copy
	#define va_copy(d,s) ((d) = (s))
	#endif

	#if defined DeleteFile
	#undef DeleteFile
	#endif

	//Declarations
	namespace leveldb
	{

	namespace Win32
	{

	#define DISALLOW_COPY_AND_ASSIGN(TypeName) \
	TypeName(const TypeName&); \
	void operator=(const TypeName&)

	std::string GetCurrentDir();
	std::wstring GetCurrentDirW();

	static const std::string CurrentDir = GetCurrentDir();
	static const std::wstring CurrentDirW = GetCurrentDirW();

	std::string& ModifyPath(std::string& path);
	std::wstring& ModifyPath(std::wstring& path);

	std::string GetLastErrSz();
	std::wstring GetLastErrSzW();

	size_t GetPageSize();

	typedef void (ScheduleProc)(void) ;

	struct WorkItemWrapper
	{
	WorkItemWrapper(ScheduleProc proc_,void* content_);
	ScheduleProc proc;
	void* pContent;
	};

	DWORD WINAPI WorkItemWrapperProc(LPVOID pContent);

	class Win32SequentialFile : public SequentialFile
	{
	public:
	friend class Win32Env;
	virtual ~Win32SequentialFile();
	virtual Status Read(size_t n, Slice* result, char* scratch);
	virtual Status Skip(uint64_t n);
	BOOL isEnable();
	private:
	BOOL _Init();
	void _CleanUp();
	Win32SequentialFile(const std::string& fname);
	std::string _filename;
	::HANDLE _hFile;
	DISALLOW_COPY_AND_ASSIGN(Win32SequentialFile);
	};

	class Win32RandomAccessFile : public RandomAccessFile
	{
	public:
	friend class Win32Env;
	virtual ~Win32RandomAccessFile();
	virtual Status Read(uint64_t offset, size_t n, Slice* result,char* scratch) const;
	BOOL isEnable();
	private:
	BOOL _Init(LPCWSTR path);
	void _CleanUp();
	Win32RandomAccessFile(const std::string& fname);
	HANDLE _hFile;
	const std::string _filename;
	DISALLOW_COPY_AND_ASSIGN(Win32RandomAccessFile);
	};

	class Win32MapFile : public WritableFile
	{
	public:
	Win32MapFile(const std::string& fname);

	~Win32MapFile();
	virtual Status Append(const Slice& data);
	virtual Status Close();
	virtual Status Flush();
	virtual Status Sync();
	BOOL isEnable();
	private:
	std::string _filename;
	HANDLE _hFile;
	size_t _page_size;
	size_t _map_size; // How much extra memory to map at a time
	char* _base; // The mapped region
	HANDLE _base_handle;
	char* _limit; // Limit of the mapped region
	char* _dst; // Where to write next (in range [base_,limit_])
	char* _last_sync; // Where have we synced up to
	uint64_t _file_offset; // Offset of base_ in file
	//LARGE_INTEGER file_offset_;
	// Have we done an munmap of unsynced data?
	bool _pending_sync;

	// Roundup x to a multiple of y
	static size_t _Roundup(size_t x, size_t y);
	size_t _TruncateToPageBoundary(size_t s);
	bool _UnmapCurrentRegion();
	bool _MapNewRegion();
	DISALLOW_COPY_AND_ASSIGN(Win32MapFile);
	BOOL _Init(LPCWSTR Path);
	};

	class Win32FileLock : public FileLock
	{
	public:
	friend class Win32Env;
	virtual ~Win32FileLock();
	BOOL isEnable();
	private:
	BOOL _Init(LPCWSTR path);
	void _CleanUp();
	Win32FileLock(const std::string& fname);
	HANDLE _hFile;
	std::string _filename;
	DISALLOW_COPY_AND_ASSIGN(Win32FileLock);
	};

	class Win32Logger : public Logger
	{
	public:
	friend class Win32Env;
	virtual ~Win32Logger();
	virtual void Logv(const char* format, va_list ap);
	private:
	explicit Win32Logger(WritableFile* pFile);
	WritableFile* _pFileProxy;
	DISALLOW_COPY_AND_ASSIGN(Win32Logger);
	};

	class Win32Env : public Env
	{
	public:
	Win32Env();
	virtual ~Win32Env();
	virtual Status NewSequentialFile(const std::string& fname,
	SequentialFile** result);

	virtual Status NewRandomAccessFile(const std::string& fname,
	RandomAccessFile** result);
	virtual Status NewWritableFile(const std::string& fname,
	WritableFile** result);

	virtual bool FileExists(const std::string& fname);

	virtual Status GetChildren(const std::string& dir,
	std::vector<std::string>* result);

	virtual Status DeleteFile(const std::string& fname);

	virtual Status CreateDir(const std::string& dirname);

	virtual Status DeleteDir(const std::string& dirname);

	virtual Status GetFileSize(const std::string& fname, uint64_t* file_size);

	virtual Status RenameFile(const std::string& src,
	const std::string& target);

	virtual Status LockFile(const std::string& fname, FileLock** lock);

	virtual Status UnlockFile(FileLock* lock);

	virtual void Schedule(
	void (function)(void arg),
	void* arg);

	virtual void StartThread(void (function)(void arg), void* arg);

	virtual Status GetTestDirectory(std::string* path);

	//virtual void Logv(WritableFile* log, const char* format, va_list ap);

	virtual Status NewLogger(const std::string& fname, Logger** result);

	virtual uint64_t NowMicros();

	virtual void SleepForMicroseconds(int micros);
	};

	void ToWidePath(const std::string& value, std::wstring& target) {
	wchar_t buffer[MAX_PATH];
	MultiByteToWideChar(CP_ACP, 0, value.c_str(), -1, buffer, MAX_PATH);
	target = buffer;
	}

	void ToNarrowPath(const std::wstring& value, std::string& target) {
	char buffer[MAX_PATH];
	WideCharToMultiByte(CP_ACP, 0, value.c_str(), -1, buffer, MAX_PATH, NULL, NULL);
	target = buffer;
	}

	std::string GetCurrentDir()
	{
	CHAR path[MAX_PATH];
	::GetModuleFileNameA(::GetModuleHandleA(NULL),path,MAX_PATH);
	*strrchr(path,'\\') = 0;
	return std::string(path);
	}

	std::wstring GetCurrentDirW()
	{
	WCHAR path[MAX_PATH];
	::GetModuleFileNameW(::GetModuleHandleW(NULL),path,MAX_PATH);
	*wcsrchr(path,L'\\') = 0;
	return std::wstring(path);
	}

	std::string& ModifyPath(std::string& path)
	{
	if(path[0] == '/' \|\| path[0] == '\\'){
	path = CurrentDir + path;
	}
	std::replace(path.begin(),path.end(),'/','\\');

	return path;
	}

	std::wstring& ModifyPath(std::wstring& path)
	{
	if(path[0] == L'/' \|\| path[0] == L'\\'){
	path = CurrentDirW + path;
	}
	std::replace(path.begin(),path.end(),L'/',L'\\');
	return path;
	}

	std::string GetLastErrSz()
	{
	LPWSTR lpMsgBuf;
	FormatMessageW(
	FORMAT_MESSAGE_ALLOCATE_BUFFER \|
	FORMAT_MESSAGE_FROM_SYSTEM \|
	FORMAT_MESSAGE_IGNORE_INSERTS,
	NULL,
	GetLastError(),
	0, // Default language
	(LPWSTR) &lpMsgBuf,
	0,
	NULL
	);
	std::string Err;
	ToNarrowPath(lpMsgBuf, Err);
	LocalFree( lpMsgBuf );
	return Err;
	}

	std::wstring GetLastErrSzW()
	{
	LPVOID lpMsgBuf;
	FormatMessageW(
	FORMAT_MESSAGE_ALLOCATE_BUFFER \|
	FORMAT_MESSAGE_FROM_SYSTEM \|
	FORMAT_MESSAGE_IGNORE_INSERTS,
	NULL,
	GetLastError(),
	0, // Default language
	(LPWSTR) &lpMsgBuf,
	0,
	NULL
	);
	std::wstring Err = (LPCWSTR)lpMsgBuf;
	LocalFree(lpMsgBuf);
	return Err;
	}

	WorkItemWrapper::WorkItemWrapper( ScheduleProc proc_,void* content_ ) :
	proc(proc_),pContent(content_)
	{

	}

	DWORD WINAPI WorkItemWrapperProc(LPVOID pContent)
	{
	WorkItemWrapper* item = static_cast<WorkItemWrapper*>(pContent);
	ScheduleProc TempProc = item->proc;
	void* arg = item->pContent;
	delete item;
	TempProc(arg);
	return 0;
	}

	size_t GetPageSize()
	{
	SYSTEM_INFO si;
	GetSystemInfo(&si);
	return std::max(si.dwPageSize,si.dwAllocationGranularity);
	}

	const size_t g_PageSize = GetPageSize();


	Win32SequentialFile::Win32SequentialFile( const std::string& fname ) :
	_filename(fname),_hFile(NULL)
	{
	_Init();
	}

	Win32SequentialFile::~Win32SequentialFile()
	{
	_CleanUp();
	}

	Status Win32SequentialFile::Read( size_t n, Slice* result, char* scratch )
	{
	Status sRet;
	DWORD hasRead = 0;
	if(_hFile && ReadFile(_hFile,scratch,n,&hasRead,NULL) ){
	*result = Slice(scratch,hasRead);
	} else {
	sRet = Status::IOError(_filename, Win32::GetLastErrSz() );
	}
	return sRet;
	}

	Status Win32SequentialFile::Skip( uint64_t n )
	{
	Status sRet;
	LARGE_INTEGER Move,NowPointer;
	Move.QuadPart = n;
	if(!SetFilePointerEx(_hFile,Move,&NowPointer,FILE_CURRENT)){
	sRet = Status::IOError(_filename,Win32::GetLastErrSz());
	}
	return sRet;
	}

	BOOL Win32SequentialFile::isEnable()
	{
	return _hFile ? TRUE : FALSE;
	}

	BOOL Win32SequentialFile::_Init()
	{
	std::wstring path;
	ToWidePath(_filename, path);
	_hFile = CreateFileW(path.c_str(),
	GENERIC_READ,
	FILE_SHARE_READ,
	NULL,
	OPEN_EXISTING,
	FILE_ATTRIBUTE_NORMAL,
	NULL);
	return _hFile ? TRUE : FALSE;
	}

	void Win32SequentialFile::_CleanUp()
	{
	if(_hFile){
	CloseHandle(_hFile);
	_hFile = NULL;
	}
	}

	Win32RandomAccessFile::Win32RandomAccessFile( const std::string& fname ) :
	_filename(fname),_hFile(NULL)
	{
	std::wstring path;
	ToWidePath(fname, path);
	_Init( path.c_str() );
	}

	Win32RandomAccessFile::~Win32RandomAccessFile()
	{
	_CleanUp();
	}

	Status Win32RandomAccessFile::Read(uint64_t offset,size_t n,Slice* result,char* scratch) const
	{
	Status sRet;
	OVERLAPPED ol = {0};
	ZeroMemory(&ol,sizeof(ol));
	ol.Offset = (DWORD)offset;
	ol.OffsetHigh = (DWORD)(offset >> 32);
	DWORD hasRead = 0;
	if(!ReadFile(_hFile,scratch,n,&hasRead,&ol))
	sRet = Status::IOError(_filename,Win32::GetLastErrSz());
	else
	*result = Slice(scratch,hasRead);
	return sRet;
	}

	BOOL Win32RandomAccessFile::_Init( LPCWSTR path )
	{
	BOOL bRet = FALSE;
	if(!_hFile)
	_hFile = ::CreateFileW(path,GENERIC_READ,0,NULL,OPEN_EXISTING,
	FILE_ATTRIBUTE_NORMAL \| FILE_FLAG_RANDOM_ACCESS,NULL);
	if(!_hFile \|\| _hFile == INVALID_HANDLE_VALUE )
	_hFile = NULL;
	else
	bRet = TRUE;
	return bRet;
	}

	BOOL Win32RandomAccessFile::isEnable()
	{
	return _hFile ? TRUE : FALSE;
	}

	void Win32RandomAccessFile::_CleanUp()
	{
	if(_hFile){
	::CloseHandle(_hFile);
	_hFile = NULL;
	}
	}

	size_t Win32MapFile::_Roundup( size_t x, size_t y )
	{
	return ((x + y - 1) / y) * y;
	}

	size_t Win32MapFile::_TruncateToPageBoundary( size_t s )
	{
	s -= (s & (_page_size - 1));
	assert((s % _page_size) == 0);
	return s;
	}

	bool Win32MapFile::_UnmapCurrentRegion()
	{
	bool result = true;
	if (_base != NULL) {
	if (_last_sync < _limit) {
	// Defer syncing this data until next Sync() call, if any
	_pending_sync = true;
	}
	UnmapViewOfFile(_base);
	CloseHandle(_base_handle);
	_file_offset += _limit - _base;
	_base = NULL;
	_base_handle = NULL;
	_limit = NULL;
	_last_sync = NULL;
	_dst = NULL;
	// Increase the amount we map the next time, but capped at 1MB
	if (_map_size < (1<<20)) {
	_map_size *= 2;
	}
	}
	return result;
	}

	bool Win32MapFile::_MapNewRegion()
	{
	assert(_base == NULL);
	//LONG newSizeHigh = (LONG)((file_offset_ + map_size_) >> 32);
	//LONG newSizeLow = (LONG)((file_offset_ + map_size_) & 0xFFFFFFFF);
	DWORD off_hi = (DWORD)(_file_offset >> 32);
	DWORD off_lo = (DWORD)(_file_offset & 0xFFFFFFFF);
	LARGE_INTEGER newSize;
	newSize.QuadPart = _file_offset + _map_size;
	SetFilePointerEx(_hFile, newSize, NULL, FILE_BEGIN);
	SetEndOfFile(_hFile);

	_base_handle = CreateFileMappingA(
	_hFile,
	NULL,
	PAGE_READWRITE,
	0,
	0,
	0);
	if (_base_handle != NULL) {
	_base = (char*) MapViewOfFile(_base_handle,
	FILE_MAP_ALL_ACCESS,
	off_hi,
	off_lo,
	_map_size);
	if (_base != NULL) {
	_limit = _base + _map_size;
	_dst = _base;
	_last_sync = _base;
	return true;
	}
	}
	return false;
	}

	Win32MapFile::Win32MapFile( const std::string& fname) :
	_filename(fname),
	_hFile(NULL),
	_page_size(Win32::g_PageSize),
	_map_size(_Roundup(65536, Win32::g_PageSize)),
	_base(NULL),
	_base_handle(NULL),
	_limit(NULL),
	_dst(NULL),
	_last_sync(NULL),
	_file_offset(0),
	_pending_sync(false)
	{
	std::wstring path;
	ToWidePath(fname, path);
	_Init(path.c_str());
	assert((Win32::g_PageSize & (Win32::g_PageSize - 1)) == 0);
	}

	Status Win32MapFile::Append( const Slice& data )
	{
	const char* src = data.data();
	size_t left = data.size();
	Status s;
	while (left > 0) {
	assert(_base <= _dst);
	assert(_dst <= _limit);
	size_t avail = _limit - _dst;
	if (avail == 0) {
	if (!_UnmapCurrentRegion() \|\|
	!_MapNewRegion()) {
	return Status::IOError("WinMmapFile.Append::UnmapCurrentRegion or MapNewRegion: ", Win32::GetLastErrSz());
	}
	}
	size_t n = (left <= avail) ? left : avail;
	memcpy(_dst, src, n);
	_dst += n;
	src += n;
	left -= n;
	}
	return s;
	}

	Status Win32MapFile::Close()
	{
	Status s;
	size_t unused = _limit - _dst;
	if (!_UnmapCurrentRegion()) {
	s = Status::IOError("WinMmapFile.Close::UnmapCurrentRegion: ",Win32::GetLastErrSz());
	} else if (unused > 0) {
	// Trim the extra space at the end of the file
	LARGE_INTEGER newSize;
	newSize.QuadPart = _file_offset - unused;
	if (!SetFilePointerEx(_hFile, newSize, NULL, FILE_BEGIN)) {
	s = Status::IOError("WinMmapFile.Close::SetFilePointer: ",Win32::GetLastErrSz());
	} else
	SetEndOfFile(_hFile);
	}
	if (!CloseHandle(_hFile)) {
	if (s.ok()) {
	s = Status::IOError("WinMmapFile.Close::CloseHandle: ", Win32::GetLastErrSz());
	}
	}
	_hFile = INVALID_HANDLE_VALUE;
	_base = NULL;
	_base_handle = NULL;
	_limit = NULL;

	return s;
	}

	Status Win32MapFile::Sync()
	{
	Status s;
	if (_pending_sync) {
	// Some unmapped data was not synced
	_pending_sync = false;
	if (!FlushFileBuffers(_hFile)) {
	s = Status::IOError("WinMmapFile.Sync::FlushFileBuffers: ",Win32::GetLastErrSz());
	}
	}
	if (_dst > _last_sync) {
	// Find the beginnings of the pages that contain the first and last
	// bytes to be synced.
	size_t p1 = _TruncateToPageBoundary(_last_sync - _base);
	size_t p2 = _TruncateToPageBoundary(_dst - _base - 1);
	_last_sync = _dst;
	if (!FlushViewOfFile(_base + p1, p2 - p1 + _page_size)) {
	s = Status::IOError("WinMmapFile.Sync::FlushViewOfFile: ",Win32::GetLastErrSz());
	}
	}
	return s;
	}

	Status Win32MapFile::Flush()
	{
	return Status::OK();
	}

	Win32MapFile::~Win32MapFile()
	{
	if (_hFile != INVALID_HANDLE_VALUE) {
	Win32MapFile::Close();
	}
	}

	BOOL Win32MapFile::_Init( LPCWSTR Path )
	{
	DWORD Flag = PathFileExistsW(Path) ? OPEN_EXISTING : CREATE_ALWAYS;
	_hFile = CreateFileW(Path,
	GENERIC_READ \| GENERIC_WRITE,
	FILE_SHARE_READ\|FILE_SHARE_DELETE\|FILE_SHARE_WRITE,
	NULL,
	Flag,
	FILE_ATTRIBUTE_NORMAL,
	NULL);
	if(!_hFile \|\| _hFile == INVALID_HANDLE_VALUE)
	return FALSE;
	else
	return TRUE;
	}

	BOOL Win32MapFile::isEnable()
	{
	return _hFile ? TRUE : FALSE;
	}

	Win32FileLock::Win32FileLock( const std::string& fname ) :
	_hFile(NULL),_filename(fname)
	{
	std::wstring path;
	ToWidePath(fname, path);
	_Init(path.c_str());
	}

	Win32FileLock::~Win32FileLock()
	{
	_CleanUp();
	}

	BOOL Win32FileLock::_Init( LPCWSTR path )
	{
	BOOL bRet = FALSE;
	if(!_hFile)
	_hFile = ::CreateFileW(path,0,0,NULL,CREATE_ALWAYS,FILE_ATTRIBUTE_NORMAL,NULL);
	if(!_hFile \|\| _hFile == INVALID_HANDLE_VALUE ){
	_hFile = NULL;
	}
	else
	bRet = TRUE;
	return bRet;
	}

	void Win32FileLock::_CleanUp()
	{
	::CloseHandle(_hFile);
	_hFile = NULL;
	}

	BOOL Win32FileLock::isEnable()
	{
	return _hFile ? TRUE : FALSE;
	}

	Win32Logger::Win32Logger(WritableFile* pFile) : _pFileProxy(pFile)
	{
	assert(_pFileProxy);
	}

	Win32Logger::~Win32Logger()
	{
	if(_pFileProxy)
	delete _pFileProxy;
	}

	void Win32Logger::Logv( const char* format, va_list ap )
	{
	uint64_t thread_id = ::GetCurrentThreadId();

	// We try twice: the first time with a fixed-size stack allocated buffer,
	// and the second time with a much larger dynamically allocated buffer.
	char buffer[500];
	for (int iter = 0; iter < 2; iter++) {
	char* base;
	int bufsize;
	if (iter == 0) {
	bufsize = sizeof(buffer);
	base = buffer;
	} else {
	bufsize = 30000;
	base = new char[bufsize];
	}
	char* p = base;
	char* limit = base + bufsize;

	SYSTEMTIME st;
	GetLocalTime(&st);
	p += snprintf(p, limit - p,
	"%04d/%02d/%02d-%02d:%02d:%02d.%06d %llx ",
	int(st.wYear),
	int(st.wMonth),
	int(st.wDay),
	int(st.wHour),
	int(st.wMinute),
	int(st.wMinute),
	int(st.wMilliseconds),
	static_cast<long long unsigned int>(thread_id));

	// Print the message
	if (p < limit) {
	va_list backup_ap;
	va_copy(backup_ap, ap);
	p += vsnprintf(p, limit - p, format, backup_ap);
	va_end(backup_ap);
	}

	// Truncate to available space if necessary
	if (p >= limit) {
	if (iter == 0) {
	continue; // Try again with larger buffer
	} else {
	p = limit - 1;
	}
	}

	// Add newline if necessary
	if (p == base \|\| p[-1] != '\n') {
	*p++ = '\n';
	}

	assert(p <= limit);
	DWORD hasWritten = 0;
	if(_pFileProxy){
	_pFileProxy->Append(Slice(base, p - base));
	_pFileProxy->Flush();
	}
	if (base != buffer) {
	delete[] base;
	}
	break;
	}
	}

	bool Win32Env::FileExists(const std::string& fname)
	{
	std::string path = fname;
	std::wstring wpath;
	ToWidePath(ModifyPath(path), wpath);
	return ::PathFileExistsW(wpath.c_str()) ? true : false;
	}

	Status Win32Env::GetChildren(const std::string& dir, std::vector<std::string>* result)
	{
	Status sRet;
	::WIN32_FIND_DATAW wfd;
	std::string path = dir;
	ModifyPath(path);
	path += "\\.";
	std::wstring wpath;
	ToWidePath(path, wpath);

	::HANDLE hFind = ::FindFirstFileW(wpath.c_str() ,&wfd);
	if(hFind && hFind != INVALID_HANDLE_VALUE){
	BOOL hasNext = TRUE;
	std::string child;
	while(hasNext){
	ToNarrowPath(wfd.cFileName, child);
	if(child != ".." && child != ".") {
	result->push_back(child);
	}
	hasNext = ::FindNextFileW(hFind,&wfd);
	}
	::FindClose(hFind);
	}
	else
	sRet = Status::IOError(dir,"Could not get children.");
	return sRet;
	}

	void Win32Env::SleepForMicroseconds( int micros )
	{
	::Sleep((micros + 999) /1000);
	}


	Status Win32Env::DeleteFile( const std::string& fname )
	{
	Status sRet;
	std::string path = fname;
	std::wstring wpath;
	ToWidePath(ModifyPath(path), wpath);

	if(!::DeleteFileW(wpath.c_str())) {
	sRet = Status::IOError(path, "Could not delete file.");
	}
	return sRet;
	}

	Status Win32Env::GetFileSize( const std::string& fname, uint64_t* file_size )
	{
	Status sRet;
	std::string path = fname;
	std::wstring wpath;
	ToWidePath(ModifyPath(path), wpath);

	HANDLE file = ::CreateFileW(wpath.c_str(),
	GENERIC_READ,FILE_SHARE_READ,NULL,OPEN_EXISTING,FILE_ATTRIBUTE_NORMAL,NULL);
	LARGE_INTEGER li;
	if(::GetFileSizeEx(file,&li)){
	*file_size = (uint64_t)li.QuadPart;
	}else
	sRet = Status::IOError(path,"Could not get the file size.");
	CloseHandle(file);
	return sRet;
	}

	Status Win32Env::RenameFile( const std::string& src, const std::string& target )
	{
	Status sRet;
	std::string src_path = src;
	std::wstring wsrc_path;
	ToWidePath(ModifyPath(src_path), wsrc_path);
	std::string target_path = target;
	std::wstring wtarget_path;
	ToWidePath(ModifyPath(target_path), wtarget_path);

	if(!MoveFileW(wsrc_path.c_str(), wtarget_path.c_str() ) ){
	DWORD err = GetLastError();
	if(err == 0x000000b7){
	if(!::DeleteFileW(wtarget_path.c_str() ) )
	sRet = Status::IOError(src, "Could not rename file.");
	else if(!::MoveFileW(wsrc_path.c_str(),
	wtarget_path.c_str() ) )
	sRet = Status::IOError(src, "Could not rename file.");
	}
	}
	return sRet;
	}

	Status Win32Env::LockFile( const std::string& fname, FileLock** lock )
	{
	Status sRet;
	std::string path = fname;
	ModifyPath(path);
	Win32FileLock* _lock = new Win32FileLock(path);
	if(!_lock->isEnable()){
	delete _lock;
	*lock = NULL;
	sRet = Status::IOError(path, "Could not lock file.");
	}
	else
	*lock = _lock;
	return sRet;
	}

	Status Win32Env::UnlockFile( FileLock* lock )
	{
	Status sRet;
	delete lock;
	return sRet;
	}

	void Win32Env::Schedule( void (function)(void arg), void* arg )
	{
	QueueUserWorkItem(Win32::WorkItemWrapperProc,
	new Win32::WorkItemWrapper(function,arg),
	WT_EXECUTEDEFAULT);
	}

	void Win32Env::StartThread( void (function)(void arg), void* arg )
	{
	::_beginthread(function,0,arg);
	}

	Status Win32Env::GetTestDirectory( std::string* path )
	{
	Status sRet;
	WCHAR TempPath[MAX_PATH];
	::GetTempPathW(MAX_PATH,TempPath);
	ToNarrowPath(TempPath, *path);
	path->append("leveldb\\test\\");
	ModifyPath(*path);
	return sRet;
	}

	uint64_t Win32Env::NowMicros()
	{
	#ifndef USE_VISTA_API
	#define GetTickCount64 GetTickCount
	#endif
	return (uint64_t)(GetTickCount64()*1000);
	}

	-Status Win32Env::CreateDir( const std::string& dirname )
	+static Status CreateDirInner( const std::string& dirname )
	{
	Status sRet;
	+ DWORD attr = ::GetFileAttributes(dirname.c_str());
	+ if (attr == INVALID_FILE_ATTRIBUTES) { // doesn't exist:
	+ std::size_t slash = dirname.find_last_of("\\");
	+ if (slash != std::string::npos){
	+ sRet = CreateDirInner(dirname.substr(0, slash));
	+ if (!sRet.ok()) return sRet;
	+ }
	+ BOOL result = ::CreateDirectory(dirname.c_str(), NULL);
	+ if (result == FALSE) {
	+ sRet = Status::IOError(dirname, "Could not create directory.");
	+ return sRet;
	+ }
	+ }
	+ return sRet;
	+}
	+
	+Status Win32Env::CreateDir( const std::string& dirname )
	+{
	std::string path = dirname;
	if(path[path.length() - 1] != '\\'){
	path += '\\';
	}
	ModifyPath(path);
	- if(!::MakeSureDirectoryPathExists( path.c_str() ) ){
	- sRet = Status::IOError(dirname, "Could not create directory.");
	- }
	- return sRet;
	+
	+ return CreateDirInner(path);
	}

	Status Win32Env::DeleteDir( const std::string& dirname )
	{
	Status sRet;
	std::wstring path;
	ToWidePath(dirname, path);
	ModifyPath(path);
	if(!::RemoveDirectoryW( path.c_str() ) ){
	sRet = Status::IOError(dirname, "Could not delete directory.");
	}
	return sRet;
	}

	Status Win32Env::NewSequentialFile( const std::string& fname, SequentialFile** result )
	{
	Status sRet;
	std::string path = fname;
	ModifyPath(path);
	Win32SequentialFile* pFile = new Win32SequentialFile(path);
	if(pFile->isEnable()){
	*result = pFile;
	}else {
	delete pFile;
	sRet = Status::IOError(path, Win32::GetLastErrSz());
	}
	return sRet;
	}

	Status Win32Env::NewRandomAccessFile( const std::string& fname, RandomAccessFile** result )
	{
	Status sRet;
	std::string path = fname;
	Win32RandomAccessFile* pFile = new Win32RandomAccessFile(ModifyPath(path));
	if(!pFile->isEnable()){
	delete pFile;
	*result = NULL;
	sRet = Status::IOError(path,"Could not create random access file.");
	}else
	*result = pFile;
	return sRet;
	}

	Status Win32Env::NewLogger( const std::string& fname, Logger** result )
	{
	Status sRet;
	std::string path = fname;
	Win32MapFile* pMapFile = new Win32MapFile(ModifyPath(path));
	if(!pMapFile->isEnable()){
	delete pMapFile;
	*result = NULL;
	sRet = Status::IOError(path,"could not create a logger.");
	}else
	*result = new Win32Logger(pMapFile);
	return sRet;
	}

	Status Win32Env::NewWritableFile( const std::string& fname, WritableFile** result )
	{
	Status sRet;
	std::string path = fname;
	Win32MapFile* pFile = new Win32MapFile(ModifyPath(path));
	if(!pFile->isEnable()){
	*result = NULL;
	sRet = Status::IOError(fname,Win32::GetLastErrSz());
	}else
	*result = pFile;
	return sRet;
	}

	Win32Env::Win32Env()
	{

	}

	Win32Env::~Win32Env()
	{

	}


	} // Win32 namespace

	static port::OnceType once = LEVELDB_ONCE_INIT;
	static Env* default_env;
	static void InitDefaultEnv() { default_env = new Win32::Win32Env(); }

	Env* Env::Default() {
	port::InitOnce(&once, InitDefaultEnv);
	return default_env;
	}

	} // namespace leveldb

	#endif // defined(LEVELDB_PLATFORM_WINDOWS)
	diff --git a/src/makefile.linux-mingw b/src/makefile.linux-mingw
	index efbce1f04..c3cbe90bc 100644
	--- a/src/makefile.linux-mingw
	+++ b/src/makefile.linux-mingw
	@@ -1,128 +1,129 @@
	# Copyright (c) 2009-2010 Satoshi Nakamoto
	# Distributed under the MIT/X11 software license, see the accompanying
	# file COPYING or http://www.opensource.org/licenses/mit-license.php.

	DEPSDIR:=/usr/i586-mingw32msvc

	USE_UPNP:=0
	USE_IPV6:=1

	INCLUDEPATHS= \
	-I"$(CURDIR)" \
	-I"$(CURDIR)"/obj \
	-I"$(DEPSDIR)/boost_1_50_0" \
	-I"$(DEPSDIR)/db-4.8.30.NC/build_unix" \
	-I"$(DEPSDIR)/openssl-1.0.1c/include" \
	-I"$(DEPSDIR)"

	LIBPATHS= \
	-L"$(DEPSDIR)/boost_1_50_0/stage/lib" \
	-L"$(DEPSDIR)/db-4.8.30.NC/build_unix" \
	-L"$(DEPSDIR)/openssl-1.0.1c"

	LIBS= \
	+ $(CURDIR)/leveldb/libleveldb.a $(CURDIR)/leveldb/libmemenv.a \
	-l boost_system-mt-s \
	-l boost_filesystem-mt-s \
	-l boost_program_options-mt-s \
	-l boost_thread_win32-mt-s \
	-l boost_chrono-mt-s \
	-l db_cxx \
	-l ssl \
	-l crypto

	DEFS=-D_MT -DWIN32 -D_WINDOWS -DBOOST_THREAD_USE_LIB -DBOOST_SPIRIT_THREADSAFE
	DEBUGFLAGS=-g
	CFLAGS=-O2 -w -Wall -Wextra -Wformat -Wformat-security -Wno-unused-parameter $(DEBUGFLAGS) $(DEFS) $(INCLUDEPATHS)
	# enable: ASLR, DEP and large address aware
	LDFLAGS=-Wl,--dynamicbase -Wl,--nxcompat -Wl,--large-address-aware

	TESTDEFS = -DTEST_DATA_DIR=$(abspath test/data)

	ifndef USE_UPNP
	override USE_UPNP = -
	endif
	ifneq (${USE_UPNP}, -)
	LIBPATHS += -L"$(DEPSDIR)/miniupnpc"
	LIBS += -l miniupnpc -l iphlpapi
	DEFS += -DSTATICLIB -DUSE_UPNP=$(USE_UPNP)
	endif

	ifneq (${USE_IPV6}, -)
	DEFS += -DUSE_IPV6=$(USE_IPV6)
	endif

	LIBS += -l mingwthrd -l kernel32 -l user32 -l gdi32 -l comdlg32 -l winspool -l winmm -l shell32 -l comctl32 -l ole32 -l oleaut32 -l uuid -l rpcrt4 -l advapi32 -l ws2_32 -l mswsock -l shlwapi

	# TODO: make the mingw builds smarter about dependencies, like the linux/osx builds are
	HEADERS = $(wildcard *.h)

	OBJS= \
	obj/alert.o \
	obj/version.o \
	obj/checkpoints.o \
	obj/netbase.o \
	obj/addrman.o \
	obj/crypter.o \
	obj/key.o \
	obj/db.o \
	obj/init.o \
	obj/irc.o \
	obj/keystore.o \
	obj/main.o \
	obj/net.o \
	obj/protocol.o \
	obj/bitcoinrpc.o \
	obj/rpcdump.o \
	obj/rpcnet.o \
	obj/rpcmining.o \
	obj/rpcwallet.o \
	obj/rpcblockchain.o \
	obj/rpcrawtransaction.o \
	obj/script.o \
	obj/sync.o \
	obj/util.o \
	obj/wallet.o \
	obj/walletdb.o \
	obj/noui.o \
	obj/hash.o \
	obj/bloom.o \
	obj/leveldb.o \
	obj/txdb.o

	all: bitcoind.exe

	-LIBS += $(CURDIR)/leveldb/libleveldb.a $(CURDIR)/leveldb/libmemenv.a
	DEFS += -I"$(CURDIR)/leveldb/include"
	DEFS += -I"$(CURDIR)/leveldb/helpers"
	leveldb/libleveldb.a:
	- @echo "Building LevelDB ..." && cd leveldb && CC=i586-mingw32msvc-gcc CXX=i586-mingw32msvc-g++ TARGET_OS=OS_WINDOWS_CROSSCOMPILE CXXFLAGS="-I$(INCLUDEPATHS)" LDFLAGS="-L$(LIBPATHS)" $(MAKE) libleveldb.a libmemenv.a && i586-mingw32msvc-ranlib libleveldb.a && i586-mingw32msvc-ranlib libmemenv.a && cd ..
	+ @echo "Building LevelDB ..." && cd leveldb && CC=i586-mingw32msvc-gcc CXX=i586-mingw32msvc-g++ TARGET_OS=OS_WINDOWS_CROSSCOMPILE CXXFLAGS="$(INCLUDEPATHS)" LDFLAGS="$(LIBPATHS)" $(MAKE) libleveldb.a libmemenv.a && i586-mingw32msvc-ranlib libleveldb.a && i586-mingw32msvc-ranlib libmemenv.a && cd ..
	obj/leveldb.o: leveldb/libleveldb.a

	obj/build.h: FORCE
	/bin/sh ../share/genbuild.sh obj/build.h
	version.cpp: obj/build.h
	DEFS += -DHAVE_BUILD_INFO

	obj/%.o: %.cpp $(HEADERS)
	i586-mingw32msvc-g++ -c $(CFLAGS) -o $@ $<

	bitcoind.exe: $(OBJS:obj/%=obj/%)
	i586-mingw32msvc-g++ $(CFLAGS) $(LDFLAGS) -o $@ $(LIBPATHS) $^ $(LIBS)

	TESTOBJS := $(patsubst test/%.cpp,obj-test/%.o,$(wildcard test/*.cpp))

	obj-test/%.o: test/%.cpp $(HEADERS)
	i586-mingw32msvc-g++ -c $(TESTDEFS) $(CFLAGS) -o $@ $<

	test_bitcoin.exe: $(TESTOBJS) $(filter-out obj/init.o,$(OBJS:obj/%=obj/%))
	i586-mingw32msvc-g++ $(CFLAGS) $(LDFLAGS) -o $@ $(LIBPATHS) $^ -lboost_unit_test_framework-mt-s $(LIBS)


	clean:
	-rm -f obj/*.o
	-rm -f bitcoind.exe
	-rm -f obj-test/*.o
	-rm -f test_bitcoin.exe
	-rm -f obj/build.h
	+ cd leveldb && TARGET_OS=OS_WINDOWS_CROSSCOMPILE $(MAKE) clean && cd ..

	FORCE:
	diff --git a/src/makefile.mingw b/src/makefile.mingw
	index a7a57a2a2..366d32bd8 100644
	--- a/src/makefile.mingw
	+++ b/src/makefile.mingw
	@@ -1,124 +1,139 @@
	# Copyright (c) 2009-2010 Satoshi Nakamoto
	# Distributed under the MIT/X11 software license, see the accompanying
	# file COPYING or http://www.opensource.org/licenses/mit-license.php.

	-USE_UPNP:=0
	+# Makefile for the MinGW g++ compiler/toolchain
	+#
	+# Assumes Berkeley DB, Boost, and OpenSSL have all been compiled and installed
	+# into /usr/local (/usr/local/include, /usr/local/lib).
	+#
	+# If dependencies are somewhere else, run 'make DEPSDIR=/path/'
	+#
	+# Boost libraries are given wacky names that include the particular version of
	+# boost you're using; set BOOST_SUFFIX appropriately.
	+#
	+# 'make clean' assumes it is running inside a MSYS shell, and uses 'rm'
	+# to remove files.
	+
	+USE_UPNP:=-
	USE_IPV6:=1

	+DEPSDIR?=/usr/local
	+BOOST_SUFFIX?=-mgw46-mt-sd-1_52
	+
	INCLUDEPATHS= \
	- -I"C:\boost-1.50.0-mgw" \
	- -I"C:\db-4.8.30.NC-mgw\build_unix" \
	- -I"C:\openssl-1.0.1c-mgw\include"
	+ -I"$(CURDIR)" \
	+ -I"$(DEPSDIR)/include"

	LIBPATHS= \
	- -L"C:\boost-1.50.0-mgw\stage\lib" \
	- -L"C:\db-4.8.30.NC-mgw\build_unix" \
	- -L"C:\openssl-1.0.1c-mgw"
	+ -L"$(CURDIR)/leveldb" \
	+ -L"$(DEPSDIR)/lib"

	LIBS= \
	- -l boost_system-mgw45-mt-s-1_50 \
	- -l boost_filesystem-mgw45-mt-s-1_50 \
	- -l boost_program_options-mgw45-mt-s-1_50 \
	- -l boost_thread-mgw45-mt-s-1_50 \
	- -l boost_chrono-mgw45-mt-s-1_50 \
	+ -l leveldb \
	+ -l memenv \
	+ -l boost_system$(BOOST_SUFFIX) \
	+ -l boost_filesystem$(BOOST_SUFFIX) \
	+ -l boost_program_options$(BOOST_SUFFIX) \
	+ -l boost_thread$(BOOST_SUFFIX) \
	+ -l boost_chrono$(BOOST_SUFFIX) \
	-l db_cxx \
	-l ssl \
	-l crypto

	DEFS=-DWIN32 -D_WINDOWS -DBOOST_THREAD_USE_LIB -DBOOST_SPIRIT_THREADSAFE
	DEBUGFLAGS=-g
	CFLAGS=-mthreads -O2 -w -Wall -Wextra -Wformat -Wformat-security -Wno-unused-parameter $(DEBUGFLAGS) $(DEFS) $(INCLUDEPATHS)
	# enable: ASLR, DEP and large address aware
	LDFLAGS=-Wl,--dynamicbase -Wl,--nxcompat -Wl,--large-address-aware

	TESTDEFS = -DTEST_DATA_DIR=$(abspath test/data)

	ifndef USE_UPNP
	override USE_UPNP = -
	endif
	ifneq (${USE_UPNP}, -)
	- INCLUDEPATHS += -I"C:\miniupnpc-1.6-mgw"
	- LIBPATHS += -L"C:\miniupnpc-1.6-mgw"
	LIBS += -l miniupnpc -l iphlpapi
	DEFS += -DSTATICLIB -DUSE_UPNP=$(USE_UPNP)
	endif

	ifneq (${USE_IPV6}, -)
	DEFS += -DUSE_IPV6=$(USE_IPV6)
	endif

	LIBS += -l kernel32 -l user32 -l gdi32 -l comdlg32 -l winspool -l winmm -l shell32 -l comctl32 -l ole32 -l oleaut32 -l uuid -l rpcrt4 -l advapi32 -l ws2_32 -l mswsock -l shlwapi

	# TODO: make the mingw builds smarter about dependencies, like the linux/osx builds are
	HEADERS = $(wildcard *.h)

	OBJS= \
	obj/alert.o \
	obj/version.o \
	obj/checkpoints.o \
	obj/netbase.o \
	obj/addrman.o \
	obj/crypter.o \
	obj/key.o \
	obj/db.o \
	obj/init.o \
	obj/irc.o \
	obj/keystore.o \
	obj/main.o \
	obj/net.o \
	obj/protocol.o \
	obj/bitcoinrpc.o \
	obj/rpcdump.o \
	obj/rpcnet.o \
	obj/rpcmining.o \
	obj/rpcwallet.o \
	obj/rpcblockchain.o \
	obj/rpcrawtransaction.o \
	obj/script.o \
	obj/sync.o \
	obj/util.o \
	obj/wallet.o \
	obj/walletdb.o \
	obj/hash.o \
	obj/bloom.o \
	obj/noui.o \
	obj/leveldb.o \
	obj/txdb.o


	all: bitcoind.exe

	test check: test_bitcoin.exe FORCE
	test_bitcoin.exe

	#
	# LevelDB support
	#
	-LIBS += $(CURDIR)/leveldb/libleveldb.a $(CURDIR)/leveldb/libmemenv.a
	DEFS += $(addprefix -I,$(CURDIR)/leveldb/include)
	DEFS += $(addprefix -I,$(CURDIR)/leveldb/helpers)
	-# TODO: If this fails, try adding a ranlib libleveldb.a && ranlib libmemenv.a
	+
	leveldb/libleveldb.a:
	- cd leveldb && $(MAKE) libleveldb.a libmemenv.a && cd ..
	+ cd leveldb && $(MAKE) OPT="$(DEBUGFLAGS)" TARGET_OS=NATIVE_WINDOWS libleveldb.a libmemenv.a && cd ..
	+
	obj/leveldb.o: leveldb/libleveldb.a

	obj/%.o: %.cpp $(HEADERS)
	g++ -c $(CFLAGS) -o $@ $<

	bitcoind.exe: $(OBJS:obj/%=obj/%)
	g++ $(CFLAGS) $(LDFLAGS) -o $@ $(LIBPATHS) $^ $(LIBS)

	TESTOBJS := $(patsubst test/%.cpp,obj-test/%.o,$(wildcard test/*.cpp))

	obj-test/%.o: test/%.cpp $(HEADERS)
	g++ -c $(TESTDEFS) $(CFLAGS) -o $@ $<

	test_bitcoin.exe: $(TESTOBJS) $(filter-out obj/init.o,$(OBJS:obj/%=obj/%))
	- g++ $(CFLAGS) $(LDFLAGS) -o $@ $(LIBPATHS) $^ -lboost_unit_test_framework $(LIBS)
	+ g++ $(CFLAGS) $(LDFLAGS) -o $@ $(LIBPATHS) $^ -lboost_unit_test_framework$(BOOST_SUFFIX) $(LIBS)

	clean:
	- -del /Q bitcoind test_bitcoin
	- -del /Q obj\*
	- -del /Q obj-test\*
	+ rm -f bitcoind.exe test_bitcoin.exe
	+ rm -f obj/*
	+ rm -f obj-test/*
	+ cd leveldb && $(MAKE) TARGET_OS=NATIVE_WINDOWS clean && cd ..

	FORCE:

File Metadata

Mime Type: text/x-diff
Expires: Sun, Mar 2, 11:23 (1 d, 8 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 5187587
Default Alt Text: (65 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions