# HG changeset patch # User Sebastien Jodogne # Date 1482326378 -3600 # Node ID 9ee7e2f5f1a3eac63776038ca1254919e06e07cd # Parent bfce0add15f2bc6c5b7b79fa0ae359fdd238fcde sync diff -r bfce0add15f2 -r 9ee7e2f5f1a3 Framework/Widgets/TestCairoWidget.cpp --- a/Framework/Widgets/TestCairoWidget.cpp Mon Dec 19 12:55:14 2016 +0100 +++ b/Framework/Widgets/TestCairoWidget.cpp Wed Dec 21 14:19:38 2016 +0100 @@ -32,7 +32,7 @@ #include "TestCairoWidget.h" -#include "../../Resources/Orthanc/Core/Toolbox.h" +#include "../../Resources/Orthanc/Core/SystemToolbox.h" #include @@ -51,7 +51,7 @@ NotifyChange(); - Orthanc::Toolbox::USleep(25000); + Orthanc::SystemToolbox::USleep(25000); } diff -r bfce0add15f2 -r 9ee7e2f5f1a3 Resources/CMake/CairoConfiguration.cmake --- a/Resources/CMake/CairoConfiguration.cmake Mon Dec 19 12:55:14 2016 +0100 +++ b/Resources/CMake/CairoConfiguration.cmake Wed Dec 21 14:19:38 2016 +0100 @@ -193,6 +193,10 @@ # Disable vectorized instructions when targeting archicture-independent PNaCl set(CAIRO_DEFINITIONS "${CAIRO_DEFINITIONS};HAVE_STDINT_H=1;CAIRO_HAS_PTHREAD=1;HAVE_UINT64_T=1") + elseif (${CMAKE_SYSTEM_NAME} STREQUAL "Emscripten") + # Disable vectorized instructions and threading if targeting asm.js + set(CAIRO_DEFINITIONS "${CAIRO_DEFINITIONS};HAVE_STDINT_H=1;CAIRO_HAS_PTHREAD=0;CAIRO_NO_MUTEX=1;HAVE_UINT64_T=1") + elseif (CMAKE_COMPILER_IS_GNUCXX OR CMAKE_SYSTEM_NAME STREQUAL "Darwin") diff -r bfce0add15f2 -r 9ee7e2f5f1a3 Resources/CMake/PixmanConfiguration.cmake --- a/Resources/CMake/PixmanConfiguration.cmake Mon Dec 19 12:55:14 2016 +0100 +++ b/Resources/CMake/PixmanConfiguration.cmake Wed Dec 21 14:19:38 2016 +0100 @@ -81,7 +81,23 @@ endif() - if (CMAKE_SYSTEM_NAME STREQUAL "Windows") + ########################## + ## Portable Google NaCl + ########################## + + if (CMAKE_SYSTEM_NAME STREQUAL "PNaCl") + # No hardware acceleration + set(PIXMAN_DEFINITIONS "${PIXMAN_DEFINITIONS};TLS=__thread") + + elseif (CMAKE_SYSTEM_NAME STREQUAL "Emscripten") + ########################## + ## Emscripten (asm.js) + ########################## + + # No threading support + set(PIXMAN_DEFINITIONS "${PIXMAN_DEFINITIONS};PIXMAN_NO_TLS=1;HAVE_GCC_VECTOR_EXTENSIONS") + + elseif (CMAKE_SYSTEM_NAME STREQUAL "Windows") ########################## ## Windows 32 or 64 @@ -183,14 +199,6 @@ ${PIXMAN_SOURCES_DIR}/pixman/pixman-arm-simd.c ) - ########################## - ## Portable Google NaCl - ########################## - - elseif (CMAKE_SYSTEM_NAME STREQUAL "PNaCl") - # No hardware acceleration - set(PIXMAN_DEFINITIONS "${PIXMAN_DEFINITIONS};TLS=__thread") - else() message(FATAL_ERROR "Support your platform here") endif() diff -r bfce0add15f2 -r 9ee7e2f5f1a3 Resources/Graveyard/Toolbox/DicomDataset.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/Resources/Graveyard/Toolbox/DicomDataset.cpp Wed Dec 21 14:19:38 2016 +0100 @@ -0,0 +1,315 @@ +/** + * Stone of Orthanc + * Copyright (C) 2012-2016 Sebastien Jodogne, Medical Physics + * Department, University Hospital of Liege, Belgium + * + * This program is free software: you can redistribute it and/or + * modify it under the terms of the GNU General Public License as + * published by the Free Software Foundation, either version 3 of the + * License, or (at your option) any later version. + * + * In addition, as a special exception, the copyright holders of this + * program give permission to link the code of its release with the + * OpenSSL project's "OpenSSL" library (or with modified versions of it + * that use the same license as the "OpenSSL" library), and distribute + * the linked executables. You must obey the GNU General Public License + * in all respects for all of the code used other than "OpenSSL". If you + * modify file(s) with this exception, you may extend this exception to + * your version of the file(s), but you are not obligated to do so. If + * you do not wish to do so, delete this exception statement from your + * version. If you delete this exception statement from all source files + * in the program, then also delete it here. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + **/ + + +#include "DicomDataset.h" + +#include "../../Resources/Orthanc/Core/OrthancException.h" +#include "../../Resources/Orthanc/Core/Logging.h" +#include "../../Resources/Orthanc/Core/Toolbox.h" + +#include +#include +#include + +namespace OrthancStone +{ + static uint16_t GetCharValue(char c) + { + if (c >= '0' && c <= '9') + return c - '0'; + else if (c >= 'a' && c <= 'f') + return c - 'a' + 10; + else if (c >= 'A' && c <= 'F') + return c - 'A' + 10; + else + return 0; + } + + + static uint16_t GetHexadecimalValue(const char* c) + { + return ((GetCharValue(c[0]) << 12) + + (GetCharValue(c[1]) << 8) + + (GetCharValue(c[2]) << 4) + + GetCharValue(c[3])); + } + + + static DicomDataset::Tag ParseTag(const std::string& tag) + { + if (tag.size() == 9 && + isxdigit(tag[0]) && + isxdigit(tag[1]) && + isxdigit(tag[2]) && + isxdigit(tag[3]) && + (tag[4] == '-' || tag[4] == ',') && + isxdigit(tag[5]) && + isxdigit(tag[6]) && + isxdigit(tag[7]) && + isxdigit(tag[8])) + { + uint16_t group = GetHexadecimalValue(tag.c_str()); + uint16_t element = GetHexadecimalValue(tag.c_str() + 5); + return std::make_pair(group, element); + } + else if (tag.size() == 8 && + isxdigit(tag[0]) && + isxdigit(tag[1]) && + isxdigit(tag[2]) && + isxdigit(tag[3]) && + isxdigit(tag[4]) && + isxdigit(tag[5]) && + isxdigit(tag[6]) && + isxdigit(tag[7])) + { + uint16_t group = GetHexadecimalValue(tag.c_str()); + uint16_t element = GetHexadecimalValue(tag.c_str() + 4); + return std::make_pair(group, element); + } + else + { + throw Orthanc::OrthancException(Orthanc::ErrorCode_BadFileFormat); + } + } + + void DicomDataset::Parse(const std::string& content) + { + Json::Value json; + Json::Reader reader; + if (!reader.parse(content, json)) + { + throw Orthanc::OrthancException(Orthanc::ErrorCode_BadFileFormat); + } + + Parse(json); + } + + + void DicomDataset::Parse(const Json::Value& content) + { + if (content.type() != Json::objectValue) + { + throw Orthanc::OrthancException(Orthanc::ErrorCode_BadFileFormat); + } + + Json::Value::Members members = content.getMemberNames(); + for (size_t i = 0; i < members.size(); i++) + { + Tag tag = ParseTag(members[i]); + + const Json::Value& item = content[members[i]]; + + if (item.type() != Json::objectValue || + !item.isMember("Type") || + !item.isMember("Value") || + !item.isMember("Name") || + item["Type"].type() != Json::stringValue || + item["Name"].type() != Json::stringValue) + { + throw Orthanc::OrthancException(Orthanc::ErrorCode_BadFileFormat); + } + + if (item["Type"].asString() == "String") + { + if (item["Value"].type() == Json::stringValue) + { + values_[tag] = item["Value"].asString(); + } + else + { + throw Orthanc::OrthancException(Orthanc::ErrorCode_BadFileFormat); + } + } + } + } + + + DicomDataset::DicomDataset(OrthancPlugins::IOrthancConnection& orthanc, + const std::string& instanceId) + { + std::string content; + orthanc.RestApiGet(content, "/instances/" + instanceId + "/tags"); + + Parse(content); + } + + + std::string DicomDataset::GetStringValue(const Tag& tag) const + { + Values::const_iterator it = values_.find(tag); + + if (it == values_.end()) + { + LOG(ERROR) << "Trying to access a DICOM tag that is not set in a DICOM dataset"; + throw Orthanc::OrthancException(Orthanc::ErrorCode_InexistentItem); + } + else + { + return it->second; + } + } + + + std::string DicomDataset::GetStringValue(const Tag& tag, + const std::string& defaultValue) const + { + Values::const_iterator it = values_.find(tag); + + if (it == values_.end()) + { + return defaultValue; + } + else + { + return it->second; + } + } + + + float DicomDataset::GetFloatValue(const Tag& tag) const + { + try + { + return boost::lexical_cast(Orthanc::Toolbox::StripSpaces(GetStringValue(tag))); + } + catch (boost::bad_lexical_cast&) + { + LOG(ERROR) << "Trying to access a DICOM tag that is not a float"; + throw Orthanc::OrthancException(Orthanc::ErrorCode_BadFileFormat); + } + } + + + double DicomDataset::GetDoubleValue(const Tag& tag) const + { + try + { + return boost::lexical_cast(Orthanc::Toolbox::StripSpaces(GetStringValue(tag))); + } + catch (boost::bad_lexical_cast&) + { + LOG(ERROR) << "Trying to access a DICOM tag that is not a float"; + throw Orthanc::OrthancException(Orthanc::ErrorCode_BadFileFormat); + } + } + + + int DicomDataset::GetIntegerValue(const Tag& tag) const + { + try + { + return boost::lexical_cast(Orthanc::Toolbox::StripSpaces(GetStringValue(tag))); + } + catch (boost::bad_lexical_cast&) + { + LOG(ERROR) << "Trying to access a DICOM tag that is not an integer"; + throw Orthanc::OrthancException(Orthanc::ErrorCode_BadFileFormat); + } + } + + + unsigned int DicomDataset::GetUnsignedIntegerValue(const Tag& tag) const + { + int v = GetIntegerValue(tag); + + if (v < 0) + { + throw Orthanc::OrthancException(Orthanc::ErrorCode_BadFileFormat); + } + else + { + return static_cast(v); + } + } + + + void DicomDataset::GetVectorValue(Vector& vector, + const Tag& tag) const + { + if (!GeometryToolbox::ParseVector(vector, Orthanc::Toolbox::StripSpaces(GetStringValue(tag)))) + { + LOG(ERROR) << "Trying to access a DICOM tag that is not a vector"; + throw Orthanc::OrthancException(Orthanc::ErrorCode_BadFileFormat); + } + } + + + void DicomDataset::GetVectorValue(Vector& vector, + const Tag& tag, + size_t expectedSize) const + { + GetVectorValue(vector, tag); + + if (vector.size() != expectedSize) + { + LOG(ERROR) << "A vector in a DICOM tag has a bad size"; + throw Orthanc::OrthancException(Orthanc::ErrorCode_BadFileFormat); + } + } + + + void DicomDataset::Print() const + { + for (Values::const_iterator it = values_.begin(); it != values_.end(); ++it) + { + printf("%04x,%04x = [%s]\n", it->first.first, it->first.second, it->second.c_str()); + } + printf("\n"); + } + + + bool DicomDataset::IsGrayscale() const + { + std::string photometric = Orthanc::Toolbox::StripSpaces(GetStringValue(DICOM_TAG_PHOTOMETRIC_INTERPRETATION)); + + return (photometric == "MONOCHROME1" || + photometric == "MONOCHROME2"); + } + + + void DicomDataset::GetPixelSpacing(double& spacingX, + double& spacingY) const + { + if (HasTag(DICOM_TAG_PIXEL_SPACING)) + { + Vector spacing; + GetVectorValue(spacing, DICOM_TAG_PIXEL_SPACING, 2); + spacingX = spacing[0]; + spacingY = spacing[1]; + } + else + { + spacingX = 1.0; + spacingY = 1.0; + } + } +} diff -r bfce0add15f2 -r 9ee7e2f5f1a3 Resources/Graveyard/Toolbox/DicomDataset.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/Resources/Graveyard/Toolbox/DicomDataset.h Wed Dec 21 14:19:38 2016 +0100 @@ -0,0 +1,121 @@ +/** + * Stone of Orthanc + * Copyright (C) 2012-2016 Sebastien Jodogne, Medical Physics + * Department, University Hospital of Liege, Belgium + * + * This program is free software: you can redistribute it and/or + * modify it under the terms of the GNU General Public License as + * published by the Free Software Foundation, either version 3 of the + * License, or (at your option) any later version. + * + * In addition, as a special exception, the copyright holders of this + * program give permission to link the code of its release with the + * OpenSSL project's "OpenSSL" library (or with modified versions of it + * that use the same license as the "OpenSSL" library), and distribute + * the linked executables. You must obey the GNU General Public License + * in all respects for all of the code used other than "OpenSSL". If you + * modify file(s) with this exception, you may extend this exception to + * your version of the file(s), but you are not obligated to do so. If + * you do not wish to do so, delete this exception statement from your + * version. If you delete this exception statement from all source files + * in the program, then also delete it here. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + **/ + + +#pragma once + +#include "GeometryToolbox.h" +#include "../../Resources/Orthanc/Plugins/Samples/Common/IOrthancConnection.h" + +#include +#include +#include + +namespace OrthancStone +{ + // This class is NOT thread-safe + // This is a lightweight alternative to Orthanc::DicomMap + class DicomDataset : public boost::noncopyable + { + public: + typedef std::pair Tag; + + private: + typedef std::map Values; + + Values values_; + + void Parse(const std::string& content); + + void Parse(const Json::Value& content); + + public: + DicomDataset(const std::string& content) + { + Parse(content); + } + + DicomDataset(const Json::Value& content) + { + Parse(content); + } + + DicomDataset(OrthancPlugins::IOrthancConnection& orthanc, + const std::string& instanceId); + + bool HasTag(const Tag& tag) const + { + return values_.find(tag) != values_.end(); + } + + std::string GetStringValue(const Tag& tag) const; + + std::string GetStringValue(const Tag& tag, + const std::string& defaultValue) const; + + float GetFloatValue(const Tag& tag) const; + + double GetDoubleValue(const Tag& tag) const; + + int GetIntegerValue(const Tag& tag) const; + + unsigned int GetUnsignedIntegerValue(const Tag& tag) const; + + void GetVectorValue(Vector& vector, + const Tag& tag, + size_t expectedSize) const; + + void GetVectorValue(Vector& vector, + const Tag& tag) const; + + void Print() const; + + bool IsGrayscale() const; + + void GetPixelSpacing(double& spacingX, + double& spacingY) const; + }; + + + static const DicomDataset::Tag DICOM_TAG_COLUMNS(0x0028, 0x0011); + static const DicomDataset::Tag DICOM_TAG_IMAGE_ORIENTATION_PATIENT(0x0020, 0x0037); + static const DicomDataset::Tag DICOM_TAG_IMAGE_POSITION_PATIENT(0x0020, 0x0032); + static const DicomDataset::Tag DICOM_TAG_NUMBER_OF_FRAMES(0x0028, 0x0008); + static const DicomDataset::Tag DICOM_TAG_PIXEL_REPRESENTATION(0x0028, 0x0103); + static const DicomDataset::Tag DICOM_TAG_PIXEL_SPACING(0x0028, 0x0030); + static const DicomDataset::Tag DICOM_TAG_RESCALE_INTERCEPT(0x0028, 0x1052); + static const DicomDataset::Tag DICOM_TAG_RESCALE_SLOPE(0x0028, 0x1053); + static const DicomDataset::Tag DICOM_TAG_ROWS(0x0028, 0x0010); + static const DicomDataset::Tag DICOM_TAG_SLICE_THICKNESS(0x0018, 0x0050); + static const DicomDataset::Tag DICOM_TAG_WINDOW_CENTER(0x0028, 0x1050); + static const DicomDataset::Tag DICOM_TAG_WINDOW_WIDTH(0x0028, 0x1051); + static const DicomDataset::Tag DICOM_TAG_PHOTOMETRIC_INTERPRETATION(0x0028, 0x0004); +} diff -r bfce0add15f2 -r 9ee7e2f5f1a3 Resources/Orthanc/Core/SystemToolbox.cpp --- a/Resources/Orthanc/Core/SystemToolbox.cpp Mon Dec 19 12:55:14 2016 +0100 +++ b/Resources/Orthanc/Core/SystemToolbox.cpp Wed Dec 21 14:19:38 2016 +0100 @@ -123,7 +123,7 @@ barrierEvent_ = ServerBarrierEvent_Stop; while (!(*stopFlag || finish_)) { - Toolbox::USleep(100 * 1000); + SystemToolbox::USleep(100 * 1000); } #if defined(_WIN32) @@ -152,6 +152,18 @@ } + void SystemToolbox::USleep(uint64_t microSeconds) + { +#if defined(_WIN32) + ::Sleep(static_cast(microSeconds / static_cast(1000))); +#elif defined(__linux__) || defined(__APPLE__) || defined(__FreeBSD_kernel__) || defined(__FreeBSD__) || defined(__native_client__) + usleep(microSeconds); +#else +#error Support your platform here +#endif + } + + static std::streamsize GetStreamSize(std::istream& f) { // http://www.cplusplus.com/reference/iostream/istream/tellg/ diff -r bfce0add15f2 -r 9ee7e2f5f1a3 Resources/Orthanc/Core/SystemToolbox.h --- a/Resources/Orthanc/Core/SystemToolbox.h Mon Dec 19 12:55:14 2016 +0100 +++ b/Resources/Orthanc/Core/SystemToolbox.h Wed Dec 21 14:19:38 2016 +0100 @@ -50,6 +50,8 @@ { namespace SystemToolbox { + void USleep(uint64_t microSeconds); + ServerBarrierEvent ServerBarrier(const bool& stopFlag); ServerBarrierEvent ServerBarrier(); diff -r bfce0add15f2 -r 9ee7e2f5f1a3 Resources/Orthanc/Core/Toolbox.cpp --- a/Resources/Orthanc/Core/Toolbox.cpp Mon Dec 19 12:55:14 2016 +0100 +++ b/Resources/Orthanc/Core/Toolbox.cpp Wed Dec 21 14:19:38 2016 +0100 @@ -90,18 +90,6 @@ namespace Orthanc { - void Toolbox::USleep(uint64_t microSeconds) - { -#if defined(_WIN32) - ::Sleep(static_cast(microSeconds / static_cast(1000))); -#elif defined(__linux__) || defined(__APPLE__) || defined(__FreeBSD_kernel__) || defined(__FreeBSD__) || defined(__native_client__) - usleep(microSeconds); -#else -#error Support your platform here -#endif - } - - void Toolbox::ToUpperCase(std::string& s) { std::transform(s.begin(), s.end(), s.begin(), toupper); diff -r bfce0add15f2 -r 9ee7e2f5f1a3 Resources/Orthanc/Core/Toolbox.h --- a/Resources/Orthanc/Core/Toolbox.h Mon Dec 19 12:55:14 2016 +0100 +++ b/Resources/Orthanc/Core/Toolbox.h Wed Dec 21 14:19:38 2016 +0100 @@ -78,8 +78,6 @@ namespace Toolbox { - void USleep(uint64_t microSeconds); - void ToUpperCase(std::string& s); // Inplace version void ToLowerCase(std::string& s); // Inplace version diff -r bfce0add15f2 -r 9ee7e2f5f1a3 Resources/Orthanc/Core/WebServiceParameters.cpp --- a/Resources/Orthanc/Core/WebServiceParameters.cpp Mon Dec 19 12:55:14 2016 +0100 +++ b/Resources/Orthanc/Core/WebServiceParameters.cpp Wed Dec 21 14:19:38 2016 +0100 @@ -34,7 +34,6 @@ #include "WebServiceParameters.h" #include "../Core/Logging.h" -#include "../Core/Toolbox.h" #include "../Core/OrthancException.h" #if ORTHANC_SANDBOXED == 0 diff -r bfce0add15f2 -r 9ee7e2f5f1a3 Resources/Orthanc/Plugins/Samples/Common/DicomPath.cpp --- a/Resources/Orthanc/Plugins/Samples/Common/DicomPath.cpp Mon Dec 19 12:55:14 2016 +0100 +++ b/Resources/Orthanc/Plugins/Samples/Common/DicomPath.cpp Wed Dec 21 14:19:38 2016 +0100 @@ -49,20 +49,20 @@ } - DicomPath::DicomPath(DicomTag sequence, + DicomPath::DicomPath(const DicomTag& sequence, size_t index, - DicomTag tag) : + const DicomTag& tag) : finalTag_(tag) { AddToPrefix(sequence, index); } - DicomPath::DicomPath(DicomTag sequence1, + DicomPath::DicomPath(const DicomTag& sequence1, size_t index1, - DicomTag sequence2, + const DicomTag& sequence2, size_t index2, - DicomTag tag) : + const DicomTag& tag) : finalTag_(tag) { AddToPrefix(sequence1, index1); @@ -70,13 +70,13 @@ } - DicomPath::DicomPath(DicomTag sequence1, + DicomPath::DicomPath(const DicomTag& sequence1, size_t index1, - DicomTag sequence2, + const DicomTag& sequence2, size_t index2, - DicomTag sequence3, + const DicomTag& sequence3, size_t index3, - DicomTag tag) : + const DicomTag& tag) : finalTag_(tag) { AddToPrefix(sequence1, index1); diff -r bfce0add15f2 -r 9ee7e2f5f1a3 Resources/Orthanc/Plugins/Samples/Common/DicomPath.h --- a/Resources/Orthanc/Plugins/Samples/Common/DicomPath.h Mon Dec 19 12:55:14 2016 +0100 +++ b/Resources/Orthanc/Plugins/Samples/Common/DicomPath.h Wed Dec 21 14:19:38 2016 +0100 @@ -50,30 +50,30 @@ const Prefix& GetPrefixItem(size_t depth) const; public: - DicomPath(DicomTag finalTag) : + DicomPath(const DicomTag& finalTag) : finalTag_(finalTag) { } - DicomPath(DicomTag sequence, + DicomPath(const DicomTag& sequence, size_t index, - DicomTag tag); + const DicomTag& tag); - DicomPath(DicomTag sequence1, + DicomPath(const DicomTag& sequence1, size_t index1, - DicomTag sequence2, + const DicomTag& sequence2, size_t index2, - DicomTag tag); + const DicomTag& tag); - DicomPath(DicomTag sequence1, + DicomPath(const DicomTag& sequence1, size_t index1, - DicomTag sequence2, + const DicomTag& sequence2, size_t index2, - DicomTag sequence3, + const DicomTag& sequence3, size_t index3, - DicomTag tag); + const DicomTag& tag); - void AddToPrefix(DicomTag tag, + void AddToPrefix(const DicomTag& tag, size_t position) { prefix_.push_back(std::make_pair(tag, position)); diff -r bfce0add15f2 -r 9ee7e2f5f1a3 Resources/Orthanc/Resources/CMake/BoostConfiguration.cmake --- a/Resources/Orthanc/Resources/CMake/BoostConfiguration.cmake Mon Dec 19 12:55:14 2016 +0100 +++ b/Resources/Orthanc/Resources/CMake/BoostConfiguration.cmake Wed Dec 21 14:19:38 2016 +0100 @@ -99,6 +99,13 @@ -DBOOST_LOCALE_NO_POSIX_BACKEND=1 -DBOOST_LOCALE_NO_STD_BACKEND=1 ) + + elseif (${CMAKE_SYSTEM_NAME} STREQUAL "Emscripten") + add_definitions( + -DBOOST_LOCALE_NO_POSIX_BACKEND=1 + -DBOOST_LOCALE_NO_STD_BACKEND=1 + ) + else() message(FATAL_ERROR "Support your platform here") endif() @@ -114,10 +121,15 @@ list(APPEND BOOST_SOURCES ${BOOST_REGEX_SOURCES} ${BOOST_SOURCES_DIR}/libs/date_time/src/gregorian/greg_month.cpp - ${BOOST_SOURCES_DIR}/libs/locale/src/encoding/codepage.cpp ${BOOST_SOURCES_DIR}/libs/system/src/error_code.cpp ) + if (NOT ${CMAKE_SYSTEM_NAME} STREQUAL "Emscripten") + list(APPEND BOOST_SOURCES + ${BOOST_SOURCES_DIR}/libs/locale/src/encoding/codepage.cpp + ) + endif() + if (${CMAKE_SYSTEM_NAME} STREQUAL "PNaCl" OR ${CMAKE_SYSTEM_NAME} STREQUAL "NaCl32" OR ${CMAKE_SYSTEM_NAME} STREQUAL "NaCl64")